Golang中常见的三种并发控制方式使用小结

更新时间：2024年01月28日 08:32:06 作者：落雷

这篇文章主要为大家详细介绍了如何对goroutine并发行为的控制,在Go中最常见的有三种方式：sync.WaitGroup、channel和Context,下面我们就来看看他们的具体使用吧

一提到并发控制，大家最先想到到的是锁。Go中同样提供了锁的相关机制，包括互斥锁sync.Mutex和读写锁sync.RWMutex；除此之外Go还提供了原子操作sync/atomic。但这些操作都是针对并发过程中的数据安全的，并不是针对goroutine本身的。

本文主要介绍的是对goroutine并发行为的控制。在Go中最常见的有三种方式：sync.WaitGroup、channel和Context。

1. sync.WaitGroup

sync.WaitGroup是Go语言中一个非常有用的同步原语，它可以帮助我们等待一组goroutine全部完成。在以下场景中，我们通常会使用sync.WaitGroup：

当我们需要在主函数中等待一组goroutine全部完成后再退出程序时。
当我们需要在一个函数中启动多个goroutine，并确保它们全部完成后再返回结果时。
当我们需要在一个函数中启动多个goroutine，并确保它们全部完成后再执行某个操作时。
当我们需要在一个函数中启动多个goroutine，并确保它们全部完成后再关闭某个资源时。
当我们需要在一个函数中启动多个goroutine，并确保它们全部完成后再退出循环时。

在使用sync.WaitGroup时，我们需要先创建一个sync.WaitGroup对象，然后使用它的Add方法来指定需要等待的goroutine数量。接着，我们可以使用go关键字来启动多个goroutine，并在每个goroutine中使用sync.WaitGroup对象的Done方法来表示该goroutine已经完成。最后，我们可以使用sync.WaitGroup对象的Wait方法来等待所有的goroutine全部完成。

下面是一个简单的示例，会启动3个goroutine，分别休眠0s、1s和2s，主函数会在这3个goroutine结束后退出：

package main
 
import (
	"fmt"
	"sync"
	"time"
)
 
func main() {
	var wg sync.WaitGroup
 
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			fmt.Printf("sub goroutine sleep: %ds\n", i)
			time.Sleep(time.Duration(i) * time.Second)
		}(i)
	}
 
	wg.Wait()
	fmt.Println("main func done")
}

2. channel

在Go语言中，使用channel可以帮助我们更好地控制goroutine的并发。以下是一些常见的使用channel来控制goroutine并发的方法：

2.1 使用无缓冲channel进行同步

我们可以使用一个无缓冲的channel来实现生产者-消费者模式，其中一个goroutine负责生产数据，另一个goroutine负责消费数据。当生产者goroutine将数据发送到channel时，消费者goroutine会阻塞等待数据的到来。这样，我们可以确保生产者和消费者之间的数据同步。

下面是一个简单的示例代码：

package main
 
import (
    "fmt"
    "sync"
    "time"
)
 
func producer(ch chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < 10; i++ {
        ch <- i
        fmt.Println("produced", i)
        time.Sleep(100 * time.Millisecond)
    }
    close(ch)
}
 
func consumer(ch chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := range ch {
        fmt.Println("consumed", i)
        time.Sleep(150 * time.Millisecond)
    }
}
 
func main() {
    var wg sync.WaitGroup
    ch := make(chan int)
 
    wg.Add(2)
    go producer(ch, &wg)
    go consumer(ch, &wg)
 
    wg.Wait()
}

在这个示例中，我们创建了一个无缓冲的channel，用于在生产者goroutine和消费者goroutine之间传递数据。生产者goroutine将数据发送到channel中，消费者goroutine从channel中接收数据。在生产者goroutine中，我们使用time.Sleep函数来模拟生产数据的时间，在消费者goroutine中，我们使用time.Sleep函数来模拟消费数据的时间。最后，我们使用sync.WaitGroup来等待所有的goroutine全部完成。

2.2 使用有缓冲channel进行限流

我们可以使用一个有缓冲的channel来限制并发goroutine的数量。在这种情况下，我们可以将channel的容量设置为我们希望的最大并发goroutine数量。然后，在启动每个goroutine之前，我们将一个值发送到channel中。在goroutine完成后，我们从channel中接收一个值。这样，我们可以保证同时运行的goroutine数量不超过我们指定的最大并发数量。

下面是一个简单的示例代码：

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var wg sync.WaitGroup
    maxConcurrency := 3
    semaphore := make(chan struct{}, maxConcurrency)
 
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            semaphore <- struct{}{}
            fmt.Println("goroutine", i, "started")
            // do some work
            fmt.Println("goroutine", i, "finished")
            <-semaphore
        }()
    }
 
    wg.Wait()
}

在这个示例中，我们创建了一个带缓冲的channel，缓冲区大小为3。然后，我们启动了10个goroutine，在每个goroutine中，我们将一个空结构体发送到channel中，表示该goroutine已经开始执行。在goroutine完成后，我们从channel中接收一个空结构体，表示该goroutine已经完成执行。这样，我们可以保证同时运行的goroutine数量不超过3。

3. Context

在Go语言中，使用Context可以帮助我们更好地控制goroutine的并发。以下是一些常见的使用Context来控制goroutine并发的方法：

3.1 超时控制

在某些情况下，我们需要对goroutine的执行时间进行限制，以避免程序长时间阻塞或者出现死锁等问题。使用Context可以帮助我们更好地控制goroutine的执行时间。我们可以创建一个带有超时时间的Context，然后将其传递给goroutine。如果goroutine在超时时间内没有完成执行，我们可以使用Context的Done方法来取消goroutine的执行。

下面是一个简单的示例代码：

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
 
    go func() {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("goroutine finished")
                return
            default:
                fmt.Println("goroutine running")
                time.Sleep(500 * time.Millisecond)
            }
        }
    }()
 
    time.Sleep(3 * time.Second)
}

在这个示例中，我们创建了一个带有超时时间的Context，然后将其传递给goroutine。在goroutine中，我们使用select语句来监听Context的Done方法，如果Context超时，我们将会取消goroutine的执行。

3.2 取消操作

在某些情况下，我们需要在程序运行过程中取消某些goroutine的执行。使用Context可以帮助我们更好地控制goroutine的取消操作。我们可以创建一个带有取消功能的Context，然后将其传递给goroutine。如果需要取消goroutine的执行，我们可以使用Context的Cancel方法来取消goroutine的执行。

下面是一个简单的示例代码：

package main
 
import (
    "context"
    "fmt"
    "sync"
    "time"
)
 
func main() {
    ctx, cancel := context.WithCancel(context.Background())
 
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            select {
            case <-ctx.Done():
                fmt.Println("goroutine finished")
                return
            default:
                fmt.Println("goroutine running")
                time.Sleep(500 * time.Millisecond)
            }
        }
    }()
 
    time.Sleep(2 * time.Second)
    cancel()
    wg.Wait()
}

在这个示例中，我们创建了一个带有取消功能的Context，然后将其传递给goroutine。在goroutine中，我们使用select语句来监听Context的Done方法，如果Context被取消，我们将会取消goroutine的执行。在主函数中，我们使用time.Sleep函数来模拟程序运行过程中的某个时刻需要取消goroutine的执行，然后调用Context的Cancel方法来取消goroutine的执行。

3.3 资源管理

在某些情况下，我们需要对goroutine使用的资源进行管理，以避免资源泄露或者出现竞争条件等问题。使用Context可以帮助我们更好地管理goroutine使用的资源。我们可以将资源与Context关联起来，然后将Context传递给goroutine。当goroutine完成执行后，我们可以使用Context来释放资源或者进行其他的资源管理操作。

下面是一个简单的示例代码：

package main
 
import (
    "context"
    "fmt"
    "sync"
    "time"
)
 
func worker(ctx context.Context, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Println("goroutine finished")
            return
        default:
            fmt.Println("goroutine running")
            time.Sleep(500 * time.Millisecond)
        }
    }
}
 
func main() {
    ctx, cancel := context.WithCancel(context.Background())
 
    var wg sync.WaitGroup
    wg.Add(1)
    go worker(ctx, &wg)
 
    time.Sleep(2 * time.Second)
    cancel()
    wg.Wait()
}

到此这篇关于Golang中常见的三种并发控制方式使用小结的文章就介绍到这了,更多相关Go并发控制方式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Go语言中HTTP客户端超时与重试的实现代码
Golang标准库虽然提供了基础的HTTP客户端实现,但在高并发、高可用场景下,我们需要更精细化的策略来应对复杂的网络环境,这篇文章主要介绍了Go语言中HTTP客户端超时与重试实现的相关资料,需要的朋友可以参考下
2026-04-04
Go构建WiFi局域网聊天室示例详解
这篇文章主要为大家介绍了Go构建WiFi局域网聊天室示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-12-12
Go语言中处理并发错误的常用方法总结
在Go语言中,错误处理一直是开发中不可或缺的一部分,尤其在并发编程场景下,由于多个goroutine同时运行,错误的传递和处理就变得更为复杂,这篇文章就介绍了一些常见的处理并发错误的方法,以供各位参考
2025-06-06
Go语言TCP从原理到代码实现详解
这篇文章主要为大家介绍了Go语言TCP从原理到代码实现详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-08-08
golang 实现时间戳和时间的转化
这篇文章主要介绍了golang 实现时间戳和时间的转化操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2021-05-05
golang实现微信小程序商城后台系统（moshopserver）
这篇文章主要介绍了golang实现微信小程序商城后台系统（moshopserver）,本文通过截图实例代码的形式给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
2020-02-02
初学Go必备的vscode插件及最常用快捷键和代码自动补全
这篇文章主要给大家介绍了关于初学vscode写Go必备的vscode插件及最常用快捷键和代码自动补全的相关资料,由于vscode是开源免费的,而且开发支持vscode的插件相对比较容易,更新速度也很快,需要的朋友可以参考下
2023-07-07
一文带你探索Go语言中的函数一等公民
你是否听说过 Go 语言中的函数是一等公民，如果没有，那么恭喜你，本文将带你一起揭开这个神秘的面纱，感兴趣的小伙伴快来和小编一起学习起来吧
2023-07-07
Go语言之嵌入类型详解
本文详细讲解了Go语言之嵌入类型，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2022-07-07
为什么Go语言把类型声明放在后面?
今天小编就为大家分享一篇关于为什么Go语言把类型声明放在后面?，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
2019-04-04