Mutex、WaitGroup和Semaphore的使用

用户1413827

发布于 2023-11-28 16:14:25

2050

发布于 2023-11-28 16:14:25

文章被收录于专栏：站长运维站长运维

Mutex、WaitGroup和Semaphore的使用

Golang是一种非常适合并发编程的语言，因为它提供了许多强大的工具来帮助我们在高度并发的环境中编写代码。在这篇文章中，我们将重点讨论Mutex、WaitGroup和Semaphore的使用，以便读者更好地理解Golang的并发编程。

1. Mutex

Mutex是一种互斥锁，用于保护共享资源不被并发访问。在Golang中，通过sync.Mutex类型来实现Mutex，其基本用法如下：

import "sync"

var mutex sync.Mutex

func foo() {
    mutex.Lock()
    defer mutex.Unlock()
    // do something
}

在这个例子中，我们首先定义了一个sync.Mutex类型的变量mutex，然后在函数foo()中使用mutex.Lock()方法获取锁，并在函数执行完毕后使用defer关键字自动释放锁。在锁定期间，其他Goroutine无法访问共享资源。

需要注意的是，Mutex的使用应该精确到最小范围。如果没有必要锁定整个函数，则应该尽可能缩小锁定范围，以便其他Goroutine能够访问非共享资源。

2. WaitGroup

WaitGroup是一种同步机制，用于等待一组Goroutine执行完成。在Golang中，通过sync.WaitGroup类型来实现WaitGroup，其基本用法如下：

import "sync"

var wg sync.WaitGroup

func foo() {
    defer wg.Done()
    // do something
}

func main() {
    wg.Add(1)
    go foo()
    wg.Wait()
    // all Goroutines finished
}

在这个例子中，我们首先定义了一个sync.WaitGroup类型的变量wg，然后在函数foo()中使用wg.Done()方法标记该Goroutine已完成。在主函数中，我们使用wg.Add(1)方法计数，表示有一组Goroutine需要等待执行完成。然后，我们使用go关键字启动一个新的Goroutine，并使用wg.Wait()方法等待所有Goroutine执行完毕。

需要注意的是，在使用WaitGroup时，每个等待的Goroutine都应该在最后调用wg.Done()方法来标记自己已完成。

3. Semaphore

Semaphore是一种同步机制，用于控制同时访问共享资源的数量。在Golang中，通过chan类型来实现Semaphore，其基本用法如下：

sem := make(chan struct{}, n)

func foo() {
    sem <- struct{}{}
    defer func() { <-sem }()
    // do something
}

在这个例子中，我们首先创建一个带缓冲区大小为n的通道sem，然后在foo()函数中使用sem <- struct{}{}语句从信号量中获取一个信号。如果信号量已满，则该Goroutine会被阻塞，直到有可用的信号为止。在函数执行完毕后，我们使用defer关键字自动释放信号。

需要注意的是，在使用Semaphore时，我们需要考虑好通道的缓冲区大小和Goroutine数量之间的关系，以避免死锁或无法控制的情况出现。

4. Mutex vs WaitGroup vs Semaphore

在使用Mutex、WaitGroup和Semaphore时，我们需要根据具体的场景选择合适的同步机制。一般来说，Mutex主要用于保护共享资源的读写，WaitGroup主要用于等待一组Goroutine执行完成，而Semaphore主要用于限制同时访问共享资源的数量。

例如，如果我们需要保护一个共享资源不被并发访问，则应该使用Mutex；如果我们需要等待多个Goroutine都执行完毕再进行下一步操作，则应该使用WaitGroup；如果我们需要限制同时访问某个共享资源的数量，则应该使用Semaphore。

同时，我们也需要注意同步机制的性能和效率。Mutex是最简单、最直接的同步机制，但它可能会造成锁竞争等问题，导致程序性能下降；WaitGroup可以更好地控制一组Goroutine的执行顺序，但它并不能限制并行度；Semaphore虽然可以很好地控制并发度，但其实现比较复杂，需要考虑通道缓冲区大小等因素。

因此，在使用这些同步机制时，我们应该根据具体情况进行选择，不断优化和调整，以达到最佳的性能和效果。

5. 实例

为了更好地理解Mutex、WaitGroup和Semaphore的使用方法，我们将结合一个实例来演示它们的应用。

假设我们有一个任务列表，其中包括若干个需要并行执行的任务。每个任务执行完毕后，都需要将结果写入一个共享文件中。我们希望在执行这些任务时，能够很好地控制并行度，并保证共享文件的线程安全。

import (
    "sync"
    "os"
)

func main() {
    taskList := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    maxConcurrentTasks := 2
    outFile, err := os.Create("result.txt")
    if err != nil {
        panic(err)
    }
    defer outFile.Close()

    var wg sync.WaitGroup
    sem := make(chan struct{}, maxConcurrentTasks)
    mutex := sync.Mutex{}

    for _, task := range taskList {
        wg.Add(1)
        sem <- struct{}{}
        go func(task int) {
            defer wg.Done()
            defer func() { <-sem }()
            result := doTask(task)
            writeToFile(outFile, result, &mutex)
        }(task)
    }

    wg.Wait()
}

func doTask(task int) string {
    // simulate task execution time
    time.Sleep(time.Second * 2)
    return fmt.Sprintf("Task %d finished", task)
}

func writeToFile(file *os.File, content string, mutex *sync.Mutex) {
    mutex.Lock()
    defer mutex.Unlock()
    if _, err := file.WriteString(content + "\n"); err != nil {
        panic(err)
    }
}

在这个例子中，我们首先定义了一个任务列表taskList和一个最大并发数maxConcurrentTasks。然后，我们使用sync.WaitGroup类型的变量wg、带缓冲区大小为maxConcurrentTasks的信号量sem和sync.Mutex类型的互斥锁mutex来控制任务执行和结果写入。

在for循环中，我们使用wg.Add(1)方法增加计数器数量，表示有一组Goroutine需要等待执行完成。然后，我们使用sem <- struct{}{}从信号量中获取一个信号，并使用go关键字启动一个新的Goroutine，执行doTask和writeToFile函数。在任务执行完成后，我们使用defer wg.Done()方法减少计数器数量，并使用defer func() { <-sem }()释放信号。同时，我们使用mutex.Lock()方法保护共享文件的读写操作。

需要注意的是，在writeToFile函数中，我们需要将文件操作放在互斥锁之内，以避免多个Goroutine同时访问共享文件。

通过这个例子，我们可以看到Mutex、WaitGroup和Semaphore的使用方法及其优缺点。在实际应用中，我们应该根据具体情况进行选择，并不断优化和调整，以达到最佳的性能和效果。