缓冲channel和限制goroutine并发数

最新推荐文章于 2024-01-14 11:40:25 发布
最新推荐文章于 2024-01-14 11:40:25 发布
阅读量164 收藏
点赞数
文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_36831253/article/details/134070586
版权

文章目录

要限制住goroutine的并发,
一定要阻塞住main的goroutine!
一定要阻塞住main的goroutine!
一定要阻塞住main的goroutine!
可以看最后一个例子。

由于带缓冲channel的运行时层实现带有缓冲区，因此对带缓冲channel的发送操作在缓冲区未满、接收操作在缓冲区非空的情况下是异步的（发送或接收无须阻塞等待）。

默认创建的都是非缓冲channel，读写都是即时阻塞。缓冲channel自带一块缓冲区，可以暂时存储数据，如果缓冲区满了，就会发生阻塞。

  • 对一个带缓冲channel，在缓冲区无数据或有数据但未满的情况下，对其进行发送操作的goroutine不会阻塞；
  • 在缓冲区已满的情况下，**对其进行发送操作的goroutine会阻塞；**在缓冲区为空的情况下，对其进行接收操作的goroutine亦会阻塞。

记住缓冲区channel 阻塞的是接收或者发送操作的goroutine

下面通过案例对比缓冲channel与非缓冲channel.

package main

import (
	"fmt"
	"time"
)

func main() {
	//1.非缓冲通道
	ch1 := make(chan int)
	fmt.Println("非缓冲通道", len(ch1), cap(ch1)) //非缓冲通道 0 0
	go func() {
		data := <-ch1
		fmt.Println("获得数据", data) //获得数据 100
	}()
	ch1 <- 100
	time.Sleep(time.Second)
	fmt.Println("赋值ok", "main over...")

	//2.非缓冲通道
	ch2 := make(chan string)
	go sendData(ch2)
	for data := range ch2 {
		fmt.Println("\t 读取数据", data)
	}
	fmt.Println("main over...ch2")

	//3. 缓冲通道，缓冲区满了才会阻塞
	ch3 := make(chan string, 6)
	go sendData(ch3)
	for data := range ch3 {
		fmt.Println("ch3 \t读取数据", data)
	}
	fmt.Println("main over...ch3")
}

func sendData(ch chan string) {
	for i := 1; i <= 3; i++ {
		ch <- fmt.Sprintf("data%d", i)
		fmt.Println("往通道放数据:", i)
	}
	defer close(ch)
}

输出：

$ go run .\main.go
非缓冲通道 0 0
获得数据 100
赋值ok main over...
往通道放数据: 1
         读取数据 data1
         读取数据 data2
往通道放数据: 2
往通道放数据: 3
         读取数据 data3
main over...ch2
往通道放数据: 1
往通道放数据: 2
往通道放数据: 3
ch3     读取数据 data1
ch3     读取数据 data2
ch3     读取数据 data3
main over...ch3

非缓冲channel部分的打印结果是输入数据和接收数据交替的，这说明读写都是即时阻塞。缓冲channel部分的输入数据打印完毕以后才打印接收数据，这意味着缓冲区没有满的情况下是非阻塞的。

可以使用缓冲channel模拟生产者和消费者。

无论是单收单发还是多收多发，带缓冲channel的收发性能都要好于无缓冲channel的；对于带缓冲channel而言，选择适当容量会在一定程度上提升收发性能。

3.7.1 用作计数信号量

Go并发设计的一个惯用法是将带缓冲channel用作计数信号量（counting semaphore）。

带缓冲channel中的当前数据个数代表的是当前同时处于活动状态（处理业务）的goroutine的数量，而带缓冲channel的容量（capacity）代表允许同时处于活动状态的goroutine的最大数量。一个发往带缓冲channel的发送操作表示获取一个信号量槽位，而一个来自带缓冲channel的接收操作则表示释放一个信号量槽位。

下面是一个将带缓冲channel用作计数信号量的例子：

// chapter6/sources/go-channel-case-7.go
var active = make(chan struct{}, 3)
var jobs = make(chan int, 10)

func main() {
    go func() {
        for i := 0; i < 8; i++ {
            jobs <- (i + 1)
        }
        close(jobs)
    }()
    
    var wg sync.WaitGroup
    
    for j := range jobs {
        wg.Add(1)
        go func(j int) {
            active <- struct{}{}
            log.Printf("handle job: %d\n", j)
            time.Sleep(2 * time.Second)
            <-active
            wg.Done()
        }(j)
    }
    wg.Wait()
}

上面的示例创建了一组goroutine来处理job，同一时间最多允许3个goroutine处于活动状态。为达成这一目标，示例使用了一个容量为3的带缓冲channel，active作为计数信号量，这意味着允许同时处于活动状态的最大goroutine数量为3。我们运行一下该示例：

$go run go-channel-case-7.go 
2020/02/04 09:57:02 handle job: 8
2020/02/04 09:57:02 handle job: 4
2020/02/04 09:57:02 handle job: 1
2020/02/04 09:57:04 handle job: 2
2020/02/04 09:57:04 handle job: 3
2020/02/04 09:57:04 handle job: 7
2020/02/04 09:57:06 handle job: 6
2020/02/04 09:57:06 handle job: 5

由示例运行结果中的时间戳可以看到：虽然创建了很多goroutine，但由于计数信号量的存在，同一时间处理活动状态（正在处理job）的goroutine最多为3个。

3.7.2 使用缓存channel+sync.WaitGroup限制并发数（类似上小节）
package main

import (
	"fmt"
	"runtime"
	"sync"
	"time"
)

func main() {
	run([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, 3)
}

func run(dataList []int, limit int) {
	var wg sync.WaitGroup

	ch := make(chan struct{}, limit)
	for index, ele := range dataList {
		wg.Add(1)

		fmt.Printf("%+v\n", &wg)
		go func(ele int, index int) {
			fmt.Println("for index:", index)
			fmt.Println("nub:", runtime.NumGoroutine())
			ch <- struct{}{}
			fmt.Println("start task:", ele)
			time.Sleep(10 * time.Second)
			fmt.Println("end task:", ele)
			<-ch
			wg.Done()
		}(ele, index)

	}
	wg.Wait()
	fmt.Println("111111111111111111")
}

输出：

C:\Users\Administrator\Desktop\doc\shell\docker和k8s\项目\gotnet>go run tests/main.go
&{noCopy:{} state:{_:{} _:{} v:4294967296} sema:0}
&{noCopy:{} state:{_:{} _:{} v:8589934592} sema:0}
&{noCopy:{} state:{_:{} _:{} v:12884901888} sema:0}
&{noCopy:{} state:{_:{} _:{} v:17179869184} sema:0}
&{noCopy:{} state:{_:{} _:{} v:21474836480} sema:0}
for index: 0
nub: 6
start task: 1
for index: 3
nub: 6
start task: 4
for index: 2
nub: 6
start task: 3
for index: 4
nub: 6
&{noCopy:{} state:{_:{} _:{} v:25769803776} sema:0}
for index: 1
&{noCopy:{} state:{_:{} _:{} v:30064771072} sema:0}
&{noCopy:{} state:{_:{} _:{} v:34359738368} sema:0}
nub: 7
for index: 5
nub: 9
&{noCopy:{} state:{_:{} _:{} v:38654705664} sema:0}
for index: 7
nub: 10
&{noCopy:{} state:{_:{} _:{} v:42949672960} sema:0}
for index: 8
nub: 11
&{noCopy:{} state:{_:{} _:{} v:47244640256} sema:0}
for index: 9
nub: 12
&{noCopy:{} state:{_:{} _:{} v:51539607552} sema:0}
&{noCopy:{} state:{_:{} _:{} v:55834574848} sema:0}
&{noCopy:{} state:{_:{} _:{} v:60129542144} sema:0}
for index: 13
nub: 15
for index: 6
nub: 15
for index: 10
nub: 15
for index: 12
nub: 15
for index: 11
nub: 15
end task: 3
start task: 5
end task: 1
start task: 2
end task: 4
start task: 6
end task: 2
start task: 8
end task: 6
start task: 9
end task: 5
start task: 10
end task: 10
start task: 14
end task: 9
start task: 7
end task: 8
start task: 11
end task: 11
start task: 13
end task: 7
end task: 14
start task: 12
end task: 12
end task: 13
111111111111111111

3个一组，然后最后还剩2个一组。所有完成，就结束了主进程。

但是过程可能和一般人想的不太一样，庆看如下

  • 0-10秒只出现如下信息： 可以看出来，for循环一开始就执行完了，创建了14个goroutine, 加一个本身main的goroutine. 14+1

    C:\Users\Administrator\Desktop\doc\shell\docker和k8s\项目\gotnet>go run tests/main.go
&{noCopy:{} state:{_:{} _:{} v:4294967296} sema:0}
&{noCopy:{} state:{_:{} _:{} v:8589934592} sema:0}
&{noCopy:{} state:{_:{} _:{} v:12884901888} sema:0}
&{noCopy:{} state:{_:{} _:{} v:17179869184} sema:0}
&{noCopy:{} state:{_:{} _:{} v:21474836480} sema:0}
for index: 0
nub: 6
start task: 1
for index: 3
nub: 6
start task: 4
for index: 2
nub: 6
start task: 3
for index: 4
nub: 6
&{noCopy:{} state:{_:{} _:{} v:25769803776} sema:0}
for index: 1
&{noCopy:{} state:{_:{} _:{} v:30064771072} sema:0}
&{noCopy:{} state:{_:{} _:{} v:34359738368} sema:0}
nub: 7
for index: 5
nub: 9
&{noCopy:{} state:{_:{} _:{} v:38654705664} sema:0}
for index: 7
nub: 10
&{noCopy:{} state:{_:{} _:{} v:42949672960} sema:0}
for index: 8
nub: 11
&{noCopy:{} state:{_:{} _:{} v:47244640256} sema:0}
for index: 9
nub: 12
&{noCopy:{} state:{_:{} _:{} v:51539607552} sema:0}
&{noCopy:{} state:{_:{} _:{} v:55834574848} sema:0}
&{noCopy:{} state:{_:{} _:{} v:60129542144} sema:0}
for index: 13
nub: 15
for index: 6
nub: 15
for index: 10
nub: 15
for index: 12
nub: 15
for index: 11
nub: 15

    创建了这么多goroutine，但是因为channel的容量只有3，其他想要发送channel的goroutine阻塞了。

那要如何限制goroutine的数量呢？关键点，除了缓冲的channel以外，要使main的goroutine也阻塞，这时候，需要将channel的发送和接收分离。

package main

import (
	"fmt"
	"runtime"
	"sync"
	"time"
)

func main() {
	run([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, 3)

}

func run(dataList []int, limit int) {
	var wg sync.WaitGroup

	ch := make(chan struct{}, limit)
	for index, ele := range dataList {
		wg.Add(1)
        ch <- struct{}{} //关键代码,这行不要放在go func()里， 此时因为ch满了，main也阻塞了，不会继续for循环创建goroutine了。
		fmt.Printf("%+v\n", &wg)
		go func(ele int, index int) {
			fmt.Println("for index:", index)
			fmt.Println("nub:", runtime.NumGoroutine())

			fmt.Println("start task:", ele)
			time.Sleep(10 * time.Second)
			fmt.Println("end task:", ele)
			<-ch
			wg.Done()
		}(ele, index)

	}
	wg.Wait()
	fmt.Println("111111111111111111")
}

关键点在于要阻塞住main，所以必须main参与了发送或者接受。利用缓冲channel的特性。

缓冲channel自带一块缓冲区，可以暂时存储数据，如果缓冲区满了，就会发生阻塞。

  • 对一个带缓冲channel，在缓冲区无数据或有数据但未满的情况下，对其进行发送操作的goroutine不会阻塞；
  • 在缓冲区已满的情况下，**对其进行发送操作的goroutine会阻塞；**在缓冲区为空的情况下，对其进行接收操作的goroutine亦会阻塞。
京金
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
r1笔记day27 goroutine and channel
01-20
在Go语言中，`goroutine` 和 `channel` 是并发编程的核心组件，它们使得Go能够高效地处理多任务并行。下面将详细解释这两个概念以及如何在代码中使用。 首先，`goroutine` 可以理解为轻量级的线程，由Go运行时管理...
浅谈Go语言并发机制
09-21
在Go中，`goroutine`是轻量级的线程，由语言本身支持，创建和销毁的成本远低于操作系统级别的线程。通过使用`go`关键字，我们可以轻松启动一个新的goroutine，如下所示： ```go // 创建一个goroutine执行...
go Channel 并发控制
yang_jin_yuan的博客
12-08 368
1.前言 channel一般用于协程之间的通信，channel也可以用于并发控制。比如主协程启动N个子协程，主协程等待所有子协程退出后再继续后续流程，这种场景下channel也可轻易实现。 2. 场景示例 package main import ( "time" "fmt" ) func Process(ch chan int) { //Do some work... time.Sleep(time.Second) ch <- 1 //管道中写入一
Golang控制goroutine并发数的N种方法
蜗牛沐雨
03-04 574
golang控制协程并发数实现的N种方式
控制goroutine并发数量
qq_38604364的博客
01-14 439
代码中创建了10个缓冲区的channel，当channel被填满时，继续写入会被阻塞；当goroutine运行完成之后，除了原有的wg.Done()，我们需要从channel读取走一个数据，来允许新的goroutine运行。通过这种方式，我们控制最多只能运行10个goroutine，当超过10个时需要等待前面运行的goroutine结束。计算一个数字的各个位数之和，例如数字123，结果为1+2+3=6。可以有效控制goroutine数量，防止暴涨。本质上是生产者消费者模型。随机生成数字进行计算。
goroutine和channel 如何控制并发顺序？
面向生活编程
02-20 2754
文章目录写在前面分析1. goroutine2. select3. sync.WaitGroup4. channel5. 代码解释完整 写在前面 最近有同学问我这个问题。 题目意思是 利用goroutine和channel 连续输出10次，dog，cat，fish，并且都要按照这个dog，cat，fish的顺序输出。 分析 题目既然要求是使用goroutine，那么我们肯定是要控制好这个并发的顺序。因为并发是具有随机性的，这个题目并不难，很典型的chan控制进程之间的顺序。 那我们先了解一下 goro
Golang 基础：原生并发 goroutine channel 和 select 常见使用场景
张拭心的博客 shixinzhang
04-20 3597
一文掌握 goroutine channel select 的使用
Golang 【basic_leaming】goroutine channel 实现并发和并行
wgchen
12-27 256
Golang 【basic_leaming】goroutine channel 实现并发和并行
golang并发之Goroutine & channel完全解读
qq_38151401的博客
05-01 1373
1、一个通道发送和接收数据，默认是阻塞的。 如果只有写数据，会发生死锁；如果只有读数据，也会发生死锁。 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报fatal error: all goroutines are asleep - deadlock! 当我们给管道写入数据时，不能超过其容量 2、关闭通道和通道上范围循环 使用内置函数close可以关闭channel...
Go 并发 多线程 goroutine channel 实例
软件工程小施同学 的专栏
07-29 1632
Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。 一、goruntine goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。 goroutine 语法格式： go 函数名( 参数列表 ) 例如： go f(x, y, z) 开启一个新的 goroutine: f(x, y, z) Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutin
16-Go语言并发之goroutine,channel
weixin_38753143的博客
07-03 736
首先我们先了解几个与并发编程相关的概念。进程：程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立的单位。线程：操作系统调度执行的最小单位。协程：非操作系统提供而是由用户自行创建和控制的用户态线程，比线程更轻量级。Go语言中的并发程序主要是通过基于CSP的goroutine和channel来实现，当然也支持使用传统的多线程共享内存的并发方式。Goroutine是GO语言支持并发的核心，在一个GO程序中同时创建成百上千个goroutine是非常普遍的，一个goroutine会以一个很小的栈开始其生
go-concurrency:Go并发模式示例
05-16
在大量并发操作的场景下，使用协程池可以限制并发数，避免过多的goroutines消耗系统资源。你可以自定义协程池来处理特定的任务，比如限制网络请求的数量。 8. Channel缓冲区 无缓冲的channel在通信时会导致...
Go语言构建高并发分布式系统实践.ppt
08-21
2. **并发性能**：Go语言的并发模型基于CSP（Communicating Sequential Processes）理论，通过goroutine和channel实现数据的同步和通信，避免了传统多线程模型中的锁竞争问题，降低了资源消耗。 3. **内存管理**：...
channelDemo.zip
07-02
在Golang中，通道（Channel）是并发编程的核心机制之一，它允许goroutines（轻量级线程）之间安全地共享数据，实现同步和通信。本文将深入探讨Golang的通道(channel)及其在实际编程中的应用，特别是通过一个具体的...
使用 React 和 Redux 进行井字游戏并附带源代码.zip
最新发布
07-24
项目：使用 React 和 Redux 进行井字游戏并附带源代码 使用 react 和 redux 的井字游戏是一个简单的 react 项目。整个项目都是使用 react components 和redux制作的。游戏很简单，玩法也很多。要运行此项目，您必须先安装 NodeJS。 关于项目 井字游戏反应而 redux 是使用ReactJS开发的。说到这个游戏，它具有高级功能和游戏玩法。要运行此项目，首先，您必须安装费用到您的系统。然后运行npm安装然后开始运行npm开始。游戏启动后，您可以选择不同的游戏选项。您还可以选择所需的网格框数量。此外，您还可以选择对手的类型。 要运行此项目，您需要 在计算机上安装NodeJS 并使用现代浏览器，例如 Google Chrome、  Mozilla Firefox。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
使用 JavaScript 编写的专注力游戏（附源代码）.zip
07-24
项目：JavaScript 中的专注力游戏（附源代码） 专注力游戏是一个使用 JavaScript、CSS 和 HTML 开发的简单项目。这款游戏很有趣。玩家必须点击移动的框并获得分数。要点击正确的位置，玩家需要在这个游戏中集中注意力。这款游戏可以帮助玩家练习以进一步增强他们的专注力。 游戏制作 这个游戏项目仅使用 HTML、CSS 和 JavaScript。说到这个游戏的特点，用户必须单击移动框并得分。游戏有三种模式：简单、中等和困难。游戏的 PC 控制非常简单。您只需使用光标单击移动框的碎片即可。 该游戏包含大量的 javascript 以确保游戏正常运行。 如何运行该项目？ 要运行此游戏，您不需要任何类型的本地服务器，但需要浏览器。我们建议您使用现代浏览器，如 Google Chrome 和 Mozilla Firefox。要玩游戏，首先，单击 index.html 文件在浏览器中打开游戏。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
人脸识别方案资料61EDA-C1590.zip
07-24
人脸识别方案资料61EDA_C1590.zip
316、基于DK124设计的离线式开关电源设计12V 2A（原理图、PCB图、BOM表、设计说明）
07-24
316、基于DK124设计的离线式开关电源设计12V 2A（原理图、PCB图、BOM表、设计说明） 该设计为DK124控制的开关电源，实现12V 2A输出； 功能： 1、使用DK124核心控制； 2、反激式开关电源拓扑设计； 3、实现12V 2A输出； 4、市电输入； 5、整流、滤波、变压器等电路； 6、原理图、PCB图、BOM表、设计说明；
"学习Go语言基础的goroutine和channel并发编程
"Go语言中的goroutine和channel是并发编程的重要概念。在Go语言中，每一个并发的执行单元叫做一个goroutine。并发指的是逻辑上具备同时处理多个任务的能力，而并行则是物理上在同一时刻执行多个并发任务。当一个程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值