Zhong__Golang并发协程/Channel控制

已于 2022-03-11 17:26:17 修改
阅读量889 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Go 文章标签： golang go并发 go协程控制 go channel go程控制
于 2022-03-10 10:26:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anyedianxia/article/details/123394357

时间：2022.03.10

环境：Windows10 Golang1.17

目的：Golang并发协程控制

说明：

作者：Zhong QQ交流群：121160124 欢迎加入！

目录

Channel特性

Channel关闭原则

实例

1个发送者 1个接收者

1个发送者 n个接收者

n个发送者 1个接收者

n个发送者 n个接收者

Channel特性

  • 对一个已关闭的通道写入数据  ❌
  • 关闭一个已关闭的通道  ❌
  • 对一个已关闭的通道，读取数据 ✅

Channel关闭原则

  • 不要在消费端(接收者)关闭channel，不要在有多个并行的生产者时对channel执行关闭操作。
  • 当只有一个发送者时，无论有多少接收者，业务通道都应由唯一发送者关闭。
  • 当有多个发送者，一个接收者时，应借助管理通道，由业务通道唯一接收者充当管理通道的发送者，其他业务通道的发送者充当接收者
  • 当有多个发送者，多个接收者时，这是最复杂的，不仅要管理通道，还要另起一个专门的媒介协程，新增一个媒介通道，但核心逻辑都是一样。
  • channel在没有任何goroutine引用的时候会自行关闭，而不需要显示进行关闭。 main程(主程)也是一个go程
  • 推荐使用context管理go程  上面原则用context可以更简单达到目的

实例

1个发送者 1个接收者

/*
1个发送者 1个接收者
*/
package main

import (
   "fmt"
   "time"
)

func main() {
   start_time := time.Now()
   var ch = make(chan int)

   // 发送者 自行管理channel
   go func() {
      for i := 0; i < 10; i++ {
         ch <- i
      }
      close(ch)
   }()

   // 接受者
   for v := range ch {
      fmt.Println(v)
   }

   fmt.Printf("执行完成! 耗时：%v", time.Since(start_time))
}

context实现

package main

import (
   "context"
   "fmt"
   "sync"
   "time"
)

func main() {
   start_time := time.Now()
   ctx, cancel := context.WithCancel(context.Background())
   defer cancel()
   var ch = make(chan int)
   var wg sync.WaitGroup
   wg.Add(1)

   // 发送者 自行管理channel
   go func() {
      for i := 0; i < 10; i++ {
         ch <- i
      }
      cancel()
   }()

   // 接受者
   go func() {
      defer wg.Done()
   loop:
      for {
         select {
         case <-ctx.Done():
            break loop
         //当ch关闭时有可能抢占读取到零值  未关闭时会阻塞所以上面的ctx会执行
         case v := <-ch:
            fmt.Println(v)
         }
      }
   }()

   wg.Wait()
   fmt.Printf("执行完成! 耗时：%v", time.Since(start_time))
}

1个发送者 n个接收者

/*
1个发送者 n个接收者
*/
package main

import (
   "fmt"
   "math/rand"
   "sync"
   "time"
)

func main() {
   start_time := time.Now()

   rand.Seed(time.Now().UnixNano())

   wg := sync.WaitGroup{}
   wg.Add(100)

   dataCh := make(chan int, 100)

   // 发送者 主动关闭通道 因为接收者阻塞等待读取ch 所以不必关心此协程退出
   go func() {
      for i := 0; i < 200; i++ {
         if i >= 100 {
            close(dataCh)
            break // or return
         } else {
            dataCh <- i
         }
      }
      fmt.Println("ok")
   }()

   // 接收者
   for i := 0; i < 100; i++ {
      go func() {
         defer wg.Done()

         // 接收数据直到 dataCh 被关闭或者dataCh的数据缓存队列是空的。
         for value := range dataCh {
            fmt.Println(value)
         }
      }()
   }

   wg.Wait()
   fmt.Printf("执行完成! 耗时：%v", time.Since(start_time))
}

context实现

/*
1个发送者 n个接收者  context实现
*/
package main

import (
   "context"
   "fmt"
   "math/rand"
   "sync"
   "time"
)

func main() {
   start_time := time.Now()

   rand.Seed(time.Now().UnixNano())

   ctx, cancel := context.WithCancel(context.Background())
   defer cancel()

   wg := sync.WaitGroup{}
   wg.Add(100)

   dataCh := make(chan int, 100)

   go func() {
      for i := 0; i < 200; i++ {
         if i >= 100 {
            cancel()
            break // or return
         } else {
            dataCh <- i
         }
      }
      fmt.Println("ok")
   }()

   // 接收者
   for i := 0; i < 100; i++ {
      go func() {
         defer wg.Done()

         for {
            select {
            case <-ctx.Done():
               return
            case v := <-dataCh:
               fmt.Println(v)
            }
         }
      }()
   }

   wg.Wait()
   fmt.Printf("执行完成! 耗时：%v", time.Since(start_time))
}

n个发送者 1个接收者

根据指定条件关闭信号channel 通知发送者停止发送并返回

/*
n个发送者 1个接收者
*/
package main

import (
   "fmt"
   "math/rand"
   "sync"
   "time"
)

func main() {
   start_time := time.Now()
   rand.Seed(time.Now().UnixNano())

   const Max = 1000
   const NumSenders = 100

   wg := sync.WaitGroup{}
   wg.Add(1)

   dataCh := make(chan int)  // 业务通道

   stopCh := make(chan struct{})  // 管理通道：必须是无缓冲通道(即时退出) 其发送者是 业务通道的接收者。其接收者是 业务通道的发送者。

   // 业务通道的发送者 也是管理通道的接收者
   for i := 0; i < NumSenders; i++ {
      go func() {
         for {
            // 提前检查管理通道是否关闭 让业务通道发送者早尽量退出
            select {
            case <- stopCh:
               return
            default:
            }

            select {
            case <- stopCh:
               return
            case dataCh <- rand.Intn(Max):
            }
         }
      }()
   }

   // 业务通道的接收者，亦充当管理通道的发送者
   go func() {
      defer wg.Done()

      for value := range dataCh {
         if value == Max-1 {
            // 当达到某个条件时 通过关闭管理通道来广播给所有业务通道的发送者
            close(stopCh)
            fmt.Println(value)
            return
         }
         fmt.Println("value: ", value)
      }
   }()

   wg.Wait()
   fmt.Printf("执行完成! 耗时：%v", time.Since(start_time))
}

主线程遍历channel 发送者go程完成发送后退出 等待go程执行等待和完成后的关闭channel任务 

package main

import (
   "fmt"
   "sync"
)

func main() {
   var wg sync.WaitGroup
   ch := make(chan interface{})

   for i := 0; i < 5; i++ {
      wg.Add(1)
      i := i
      go func() {
         defer wg.Done()
         ch <- []interface{}{i}  // i不会重复
      }()
   }

   go func() {
      defer close(ch)
      wg.Wait()
   }()

   for msg := range ch {
      fmt.Println(msg)  // 数据全面
   }
}

 context实现

/*
n个发送者 1个接收者 context实现
*/
package main

import (
   "context"
   "fmt"
   "math/rand"
   "sync"
   "time"
)

func main() {
   start_time := time.Now()
   rand.Seed(time.Now().UnixNano())

   const Max = 1000
   const NumSenders = 100

   wg := sync.WaitGroup{}
   wg.Add(1)

   dataCh := make(chan int)  // 业务通道

   ctx, cancel := context.WithCancel(context.Background())
   defer cancel()

   // 业务通道的发送者 也是管理通道的接收者
   for i := 0; i < NumSenders; i++ {
      go func() {
         for {
            // 提前检查管理通道是否关闭 让业务通道发送者早尽量退出
            select {
            case <- ctx.Done():
               return
            default:
            }

            select {
            case <- ctx.Done():
               return
            case dataCh <- rand.Intn(Max):
            }
         }
      }()
   }

   // 业务通道的接收者，亦充当管理通道的发送者
   go func() {
      defer wg.Done()

      for value := range dataCh {
         if value == Max-1 {
            // 当达到某个条件时 通过关闭管理通道来广播给所有业务通道的发送者
            cancel()
            fmt.Println(value)
            return
         }
         fmt.Println("value: ", value)
      }
   }()

   wg.Wait()
   fmt.Printf("执行完成! 耗时：%v", time.Since(start_time))
}

n个发送者 n个接收者

context实现

/*
n个发送者 n个接收者 context实现
*/
package main

import (
   "context"
   "fmt"
   "math/rand"
   "strconv"
   "sync"
   "time"
)

func main() {
   rand.Seed(time.Now().UnixNano())

   ctx, cancel := context.WithCancel(context.Background())
   defer cancel()

   const Max = 100000
   const NumReceivers = 10
   const NumSenders = 1000
   wg := sync.WaitGroup{}
   wg.Add(NumReceivers)
   // 1. 业务通道
   dataCh := make(chan int)

   var stoppedBy string

   // 业务通道发送者
   for i := 0; i < NumSenders; i++ {
      go func(id string) {
         for {
            // 提前检查是否关闭
            // 让业务通道发送者早尽量退出
            select {
            case <-ctx.Done():
               return
            default:
            }
            value := rand.Intn(Max)
            select {
            case <-ctx.Done():
               return
            case dataCh <- value:
            }
         }
      }(strconv.Itoa(i))
   }

   // 业务通道的接收者
   for i := 0; i < NumReceivers; i++ {
      go func(id string) {
         defer wg.Done()
         for {
            // 提前检查ctx是否cancel
            // 让业务通道接收者早尽量退出
            select {
            case <-ctx.Done():
               return
            default:
            }
            select {
            case <-ctx.Done():
               return
            case v := <-dataCh:
               if v == 6666 {
                  stoppedBy = "接收者#" + id
                  cancel()
                  return
               }
            }
         }

      }(strconv.Itoa(i))
   }

   wg.Wait()

   fmt.Println("被" + stoppedBy + "终止了")

}

关注微信公众号  加入qq技术聊天群  121160124

 

golang控制协程并发数
mohansuibuzao的博客
05-20 935
使用channel控制协程并发数 func main() { control := make(chan interface{}, 5) // 管道的长度决定协程并发的数量 for i := 1; i <= 10; i++ { control <- i go func(j int) { fmt.Printf("go func: %d, time: %d\n", j, time.Now().Unix()) time.Sleep(time.Second) <-con
golang实现协程池
江南孟浪生的博客
08-03 757
go协程池可以看成一个被初始化的固定大小的协程循环读取函数队列，获取是否有可供调用的函数队列，如果有，则协程池中的一个协程调用并执行该函数，talk is cheap,show me the code。好了，整体代码介绍完了，希望你能对协程池有个比较简单的了解，也可以基于此代码，丰富一下逻辑。测试用的代码如下所示。
利用channel进行golang语言中的并发控制
wulitaotao96的博客
04-14 254
上程序： package main import ( "fmt" "time" ) func printi(i int,goroutine_cnt chan int) { fmt.Println(i) time.Sleep(10*time.Microsecond) <- goroutine_cnt } func main() { goroutine_cnt := make(chan int, 10) for i:=1;i<10000;i++{ goroutine_c.
golang并发控制之channel
Steven的专栏
09-07 802
并发控制之channel 我们考虑一种场景，协程A在执行过程中需要创建子协程A1、A2、A3…An，协程A创建完子协程后就等待子协程退出。针对这种场景，Go提供了三种解决方案。 Channel：使用channel控制子协程 WaitGroup：使用信号量机制控制子协程 Context：使用上下文控制子协程 三种方案各有优劣，比如Channel的优点是实现简单，清晰易懂，WaitGroup的优点是子协程的个数可以动态调整，Context的优点是对子协程派生出来的孙子协程的控制。各种解决方案的缺点是相对而言
Golang 并发控制模型
lp15929801907的博客
08-03 1379
Go语言的并发模型是CSP（通信顺序进程），提倡通过通信来进行内存共享，而不是通过共享内存来实现通信。控制并发有三种经典的方式，使用 channel 通知实现并发控制、使用 sync 包中的 WaitGroup 实现并发控制、使用 Context 上下文实现并发控制。
Golang——并发控制
最新发布
分享包括但不限于计算机基础知识、数据结构与算法、Golang技术栈。年与时驰，意与日去，遂成枯落，多不接世，悲守穷庐，将复何及！
01-14 1316
本文介绍Go并发，同步，顺序执行，设计的一些常见的场景，顺序执行主要用channel实现。在这种同步信号的使用场景中，使用无缓冲通道，可以选择不关闭通道。
golang.org/x/sys/windows
07-19
golang.org/x/sys/windows
Golang 多协程题目
weixin_45894608的博客
05-24 528
【代码】Golang 交替打印。
golang 应用协程和channel实现高并发
bubumai的博客
04-10 1243
问题：模拟100个ip向server发送请求，每个ip重复请求1000次，间隔时间不得超过3s。 package main import ( "fmt" "sync" "sync/atomic" "time" ) const IP_NUMBER = 100 type ipTestTask struct { handleOk chan struct{} idle boo...
java_celluar.zip_golang_golang 界面_java_celluar
09-21
1. **Golang编程基础**：理解Golang的基础语法，包括变量、函数、控制流、结构体等。 2. **Golang并发编程**：了解goroutines和channels，这是Golang处理并发的核心机制。 3. **gxui库的使用**：学习如何创建窗口、...
983-Golang的并发控制
LINZEYU666的博客
02-19 2195
我们考虑这么一种场景，协程A执行过程中需要创建子协程A1、A2、A3…An，协程A创建完子协程后就等待子协程退 出。针对这种场景，GO提供了三种解决方案： Channel: 使用channel控制子协程 WaitGroup : 使用信号量机制控制子协程 Context: 使用上下文控制子协程 三种方案各有优劣，比如Channel优点是实现简单，清晰易懂，WaitGroup优点是子协程个数动态可调整，Context 优点是对子协程派生出来的孙子协程的控制。缺点是相对而言的，要结合实例应用场景进行选择。 cha
golang context上下文、channel管理 Goroutine
qq_35916684的博客
07-22 1184
golang context上下文、channel管理 Goroutine 前文 工作中需要启用多个Goroutine,又想要管理好Goruntine,如何做到统一管理Goroutine。就需要使用Context包和channel处理了。 select概念 select 会阻塞等待channel消息，如果有满足则执行并退出，否则一直阻塞等待。 Go 语言 select 语句 context概念 g...
Golang语言之Channel通信，并发编程
DTCloud
04-10 246
不同于大多编程语言的多线程，golang的并发执行单元是一种称之为goroutine的携程，由于绝大部分语言在其共享数据时会用到并发锁，再加上GC，其执行效率多多少少会受到影响，golang的并发编程简单。Go是一种静态强类型的开源语言，诞生于2009年，是非常年轻的一门语言其主要目标时“兼具Python等动态语言的开发速度，同时又具备想C语言C++的安全性与应能”，其中最大的特点（优势）就是并发编程。*注意：管道的出入方式与出弹栈有所不同，前者时先入先出而后者是先入后出（如下图）多个写成最后汇总至结果。
Golang 【basic_leaming】goroutine channel 实现并发和并行
wgchen
12-27 309
Golang 【basic_leaming】goroutine channel 实现并发和并行
使用Go语言中的Channel实现并发编程
DTCloud
06-03 359
在Go语言中，Channel是一种用于在Goroutine之间进行通信的数据结构。它类似于队列，可以在一个Goroutine中将数据发送到Channel，然后在另一个Goroutine中接收这些数据。Channel提供了一种同步的方式，确保发送和接收操作按顺序进行，从而避免了并发访问共享数据的问题。
go 利用channel控制并发
肥茹的博客
04-13 590
【代码】go 利用channel控制并发。
Golang并发模式--channel高级使用
Erick Lv的笔记
11-16 1097
or-done channel 再pipeline的情况中，我们通过done来通知goroutine结束。但是，如果我们处理的channel来自系统其它分散的部分，则无法通过done来控制，因为我们不知道数据流终止的时间，此时需要引入or-done机制。or-done机制本质上是对外界数据channel的一个封装，以便我们可以实际控制。 给出代码示例： package main func main...
深度解密Go语言之context
weixin_44014995的博客
10-24 1009
什么是context context中文译作“上下文”，准确的说它是goroutine的上下文，包含goroutine的运行状态，环境，现场等信息等 context主要用来在goroutine之间传递上下文信息，包括：取消信号，超时时间，截止时间，K-V等 随着context包的引入，标准库中很多接口因此都加上了context参数，列如database/sql包。context几乎成为了并发控制和超时控制的标准做法。 context.Context 类型的值可以协调多个goroutine中的代码执行“
Go：Context控制子协程之手动cancel和自动timeout
小楼一夜听春雨
11-02 1232
context 一般来说，goroutine是平级关系，但是通过引进context可以让其有逻辑上的父子关系 也就是，父要子停，子不得不停的意思 揣摩一下哈 手动cancel package main import ( "context" "fmt" "time" ) func HandelRequest(ctx context.Context) { go WriteLog(ctx) go WriteDB(ctx) for { select { case <-ctx.Done(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我变了_我没变

随意 。。。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值