目录
聊聊Go的并发编程 （二）
go
package mainimport (
"fmt"
"time")func createWorker(id int) chan<- int {
c := make(chan int)
go worker(id, c)
return c}func worker(id int, c chan int) {
for n := range c {
fmt.Printf("Worker %d receive %c\n", id, n)
}}func channelDemo() {
var channels [10]chan<- int
for i := 0; i < 10; i++ {
channels[i] = createWorker(i)
}
for i := 0; i < 10; i++ {
channels[i] <- 'a' + i }
for i := 0; i < 10; i++ {
channels[i] <- 'A' + i }
time.Sleep(time.Millisecond)}func main() {
channelDemo()}登录后复制
package mainimport (
"fmt")type worker struct {
in chan int
done chan bool}func createWorker(id int) worker {
w := worker{
in: make(chan int),
done: make(chan bool),
}
go doWorker(id, w.in, w.done)
return w}func doWorker(id int, c chan int, done chan bool) {
for n := range c {
fmt.Printf("Worker %d receive %c\n", id, n)
done <- true
}}func channelDemo() {
var workers [10]worker for i := 0; i < 10; i++ {
workers[i] = createWorker(i)
}
for i := 0; i < 10; i++ {
workers[i].in <- 'a' + i <-workers[i].done }
for i := 0; i < 10; i++ {
workers[i].in <- 'A' + i <-workers[i].done }}func main() {
channelDemo()}登录后复制
package mainimport (
"fmt")type worker struct {
in chan int
done chan bool}func createWorker(id int) worker {
w := worker{
in: make(chan int),
done: make(chan bool),
}
go doWorker(id, w.in, w.done)
return w}func doWorker(id int, c chan int, done chan bool) {
for n := range c {
fmt.Printf("Worker %d receive %c\n", id, n)
done <- true
}}func channelDemo() {
var workers [10]worker for i := 0; i < 10; i++ {
workers[i] = createWorker(i)
}
for i, worker := range workers {
worker.in <- 'a' + i }
for i, worker := range workers {
worker.in <- 'A' + i }
for _, worker := range workers {
<-worker.done <-worker.done }}func main() {
channelDemo()}登录后复制
package mainimport (
"fmt"
"sync")type worker struct {
in chan int
wg *sync.WaitGroup}func createWorker(id int, wg *sync.WaitGroup) worker {
w := worker{
in: make(chan int),
wg: wg,
}
go doWorker(id, w.in, wg)
return w}func doWorker(id int, c chan int, wg *sync.WaitGroup) {
for n := range c {
fmt.Printf("Worker %d receive %c\n", id, n)
wg.Done()
}}func channelDemo() {
var wg sync.WaitGroup var workers [10]worker for i := 0; i < 10; i++ {
workers[i] = createWorker(i, &wg)
}
// 添加20个任务
wg.Add(20)
for i, worker := range workers {
worker.in <- 'a' + i }
for i, worker := range workers {
worker.in <- 'A' + i }
wg.Wait()}func main() {
channelDemo()}登录后复制
package mainimport (
"fmt"
"sync")type worker struct {
in chan int
done func()}func createWorker(id int, wg *sync.WaitGroup) worker {
w := worker{
in: make(chan int),
done: func() {
wg.Done()
},
}
go doWorker(id, w)
return w}func doWorker(id int, w worker) {
for n := range w.in {
fmt.Printf("Worker %d receive %c\n", id, n)
w.done()
}}func channelDemo() {
var wg sync.WaitGroup var workers [10]worker for i := 0; i < 10; i++ {
workers[i] = createWorker(i, &wg)
}
// 添加20个任务
wg.Add(20)
for i, worker := range workers {
worker.in <- 'a' + i }
for i, worker := range workers {
worker.in <- 'A' + i }
wg.Wait()}func main() {
channelDemo()}登录后复制
package mainimport (
"fmt"
"math/rand"
"time")func generator() chan int {
out := make(chan int)
go func() {
i := 0
for {
// 随机睡眠1500毫秒以内
time.Sleep(
time.Duration(rand.Intn(1500)) *
time.Millisecond)
// 往out这个channel发送i值
out <- i
i++
}
}()
return out}func main() {
// 这里需要明白如果代码为var c1, c2 chan int 则c1和c2都为nil
// 在 select里面也是可以使用的，只不过是堵塞状态！
var c1, c2 = generator(), generator()
for {
/**
select 方式进行调度
使用场景：比如有多个通道，但我打算是哪一个通道先给我数据，我就先执行谁
这个select 可以是并行执行 channel管道
*/
select {
case n := <-c1:
fmt.Printf("receive from c1 %d\n", n)
case n := <-c2:
fmt.Printf("receive from c2 %d\n", n)
}
}}登录后复制
package mainimport (
"fmt"
"math/rand"
"time")func worker(id int, c chan int) {
for n := range c {
fmt.Printf("Worker %d receive %d\n", id, n)
}}func createWorker(id int) chan<- int {
c := make(chan int)
go worker(id, c)
return c}func generator() chan int {
out := make(chan int)
go func() {
i := 0
for {
// 随机睡眠1500毫秒以内
time.Sleep(
time.Duration(rand.Intn(1500)) *
time.Millisecond)
// 往out这个channel发送i值
out <- i
i++
}
}()
return out}func main() {
// 这里需要明白如果代码为var c1, c2 chan int 则c1和c2都为nil
// 在 select里面也是可以使用的，只不过是堵塞状态！
var c1, c2 = generator(), generator()
// 直接调用createWorker方法，返回的就是一个channel
w := createWorker(0)
for {
/**
select 方式进行调度
使用场景：比如有多个通道，但我打算是哪一个通道先给我数据，我就先执行谁
这个select 可以是并行执行 channel管道
*/
select {
case n := <-c1:
w <- n case n := <-c2:
w <- n }
}}登录后复制
package mainimport (
"fmt"
"math/rand"
"time")func worker(id int, c chan int) {
for n := range c {
fmt.Printf("Worker %d receive %d\n", id, n)
}}func createWorker(id int) chan<- int {
c := make(chan int)
go worker(id, c)
return c}func generator() chan int {
out := make(chan int)
go func() {
i := 0
for {
// 随机睡眠1500毫秒以内
time.Sleep(
time.Duration(rand.Intn(1500)) *
time.Millisecond)
// 往out这个channel发送i值
out <- i
i++
}
}()
return out}func main() {
// 这里需要明白如果代码为var c1, c2 chan int 则c1和c2都为nil
// 在 select里面也是可以使用的，只不过是堵塞状态！
var c1, c2 = generator(), generator()
// 直接调用createWorker方法，返回的就是一个channel
var worker = createWorker(0)
// 这个n如果放在for循环里边，就会一直打印0，因为从c1和c2收数据需要时间，所以会把0直接传给worker
n := 0
// 使用这个标识告诉有没有值
hasValue := false
for {
// 利用nil channel的特性
var activeWorker chan<- int
if hasValue {
activeWorker = worker }
/**
select 方式进行调度
使用场景：比如有多个通道，但我打算是哪一个通道先给我数据，我就先执行谁
这个select 可以是并行执行 channel管道
*/
select {
case n = <-c1:
// 收到值的话就标记为true
hasValue = true
case n = <-c2:
// 收到值的话就标记为true
hasValue = true
case activeWorker <- n:
hasValue = false
}
}}登录后复制
package mainimport (
"fmt"
"math/rand"
"time")func worker(id int, c chan int) {
for n := range c {
// 手动让消耗速度变慢
time.Sleep(5 * time.Second)
fmt.Printf("Worker %d receive %d\n", id, n)
}}func createWorker(id int) chan<- int {
c := make(chan int)
go worker(id, c)
return c}func generator() chan int {
out := make(chan int)
go func() {
i := 0
for {
// 随机睡眠1500毫秒以内
time.Sleep(
time.Duration(rand.Intn(1500)) *
time.Millisecond)
// 往out这个channel发送i值
out <- i
i++
}
}()
return out}func main() {
// 这里需要明白如果代码为var c1, c2 chan int 则c1和c2都为nil
// 在 select里面也是可以使用的，只不过是堵塞状态！
var c1, c2 = generator(), generator()
// 直接调用createWorker方法，返回的就是一个channel
var worker = createWorker(0)
// 用来收n的值
var values []int
for {
// 利用nil channel的特性
var activeWorker chan<- int
var activeValue int
// 判断当values中有值时
if len(values) > 0 {
activeWorker = worker // 取出索引为0的值
activeValue = values[0]
}
/**
select 方式进行调度
使用场景：比如有多个通道，但我打算是哪一个通道先给我数据，我就先执行谁
这个select 可以是并行执行 channel管道
*/
select {
case n := <-c1:
// 将收到的数据存到values中
values = append(values, n)
case n := <-c2:
// 将收到的数据存到values中
values = append(values, n)
case activeWorker <- activeValue:
// 送出去后就需要把values中的第一个值拿掉
values = values[1:]
}
}}登录后复制
package mainimport (
"fmt"
"math/rand"
"time")func worker(id int, c chan int) {
for n := range c {
// 手动让消耗速度变慢
time.Sleep(time.Second)
fmt.Printf("Worker %d receive %d\n", id, n)
}}func createWorker(id int) chan<- int {
c := make(chan int)
go worker(id, c)
return c}func generator() chan int {
out := make(chan int)
go func() {
i := 0
for {
// 随机睡眠1500毫秒以内
time.Sleep(
time.Duration(rand.Intn(1500)) *
time.Millisecond)
// 往out这个channel发送i值
out <- i
i++
}
}()
return out}func main() {
// 这里需要明白如果代码为var c1, c2 chan int 则c1和c2都为nil
// 在 select里面也是可以使用的，只不过是堵塞状态！
var c1, c2 = generator(), generator()
// 直接调用createWorker方法，返回的就是一个channel
var worker = createWorker(0)
// 用来收n的值
var values []int
// 返回的是一个channel
tm := time.After(10 * time.Second)
for {
// 利用nil channel的特性
var activeWorker chan<- int
var activeValue int
// 判断当values中有值时
if len(values) > 0 {
activeWorker = worker // 取出索引为0的值
activeValue = values[0]
}
/**
select 方式进行调度
使用场景：比如有多个通道，但我打算是哪一个通道先给我数据，我就先执行谁
这个select 可以是并行执行 channel管道
*/
select {
case n := <-c1:
// 将收到的数据存到values中
values = append(values, n)
case n := <-c2:
// 将收到的数据存到values中
values = append(values, n)
case activeWorker <- activeValue:
// 送出去后就需要把values中的第一个值拿掉
values = values[1:]
case <-tm:
fmt.Println("Bye")
return
}
}}登录后复制
package mainimport (
"fmt"
"math/rand"
"time")func worker(id int, c chan int) {
for n := range c {
// 手动让消耗速度变慢
time.Sleep(time.Second)
fmt.Printf("Worker %d receive %d\n", id, n)
}}func createWorker(id int) chan<- int {
c := make(chan int)
go worker(id, c)
return c}func generator() chan int {
out := make(chan int)
go func() {
i := 0
for {
// 随机睡眠1500毫秒以内
time.Sleep(
time.Duration(rand.Intn(1500)) *
time.Millisecond)
// 往out这个channel发送i值
out <- i
i++
}
}()
return out}func main() {
// 这里需要明白如果代码为var c1, c2 chan int 则c1和c2都为nil
// 在 select里面也是可以使用的，只不过是堵塞状态！
var c1, c2 = generator(), generator()
// 直接调用createWorker方法，返回的就是一个channel
var worker = createWorker(0)
// 用来收n的值
var values []int
// 返回的是一个channel
tm := time.After(10 * time.Second)
tick := time.Tick(time.Second)
for {
// 利用nil channel的特性
var activeWorker chan<- int
var activeValue int
// 判断当values中有值时
if len(values) > 0 {
activeWorker = worker // 取出索引为0的值
activeValue = values[0]
}
/**
select 方式进行调度
使用场景：比如有多个通道，但我打算是哪一个通道先给我数据，我就先执行谁
这个select 可以是并行执行 channel管道
*/
select {
case n := <-c1:
// 将收到的数据存到values中
values = append(values, n)
case n := <-c2:
// 将收到的数据存到values中
values = append(values, n)
case activeWorker <- activeValue:
// 送出去后就需要把values中的第一个值拿掉
values = values[1:]
case <-time.After(800 * time.Millisecond):
// 如果在800毫秒没有收到数据则提示超时
fmt.Println("timeout")
case <-tick:
// 每秒获取一下values中队列的长度
fmt.Println("queue len = ", len(values))
case <-tm:
fmt.Println("Bye")
return
}
}}登录后复制
以上是聊聊Go的并发编程 （二）的详细内容。更多信息请关注PHP中文网其他相关文章！
本站声明
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
热AI工具
Undresser.AI Undress
人工智能驱动的应用程序，用于创建逼真的裸体照片
AI Clothes Remover
用于从照片中去除衣服的在线人工智能工具。
Undress AI Tool
免费脱衣服图片
Clothoff.io
AI脱衣机
Video Face Swap
使用我们完全免费的人工智能换脸工具轻松在任何视频中换脸！
热门文章
刺客信条阴影：贝壳谜语解决方案
3 周前
By DDD
Windows 11 KB5054979中的新功能以及如何解决更新问题
2 周前
By DDD
在哪里可以找到原子中的起重机控制钥匙卡
3 周前
By DDD
刺客信条阴影 - 如何找到铁匠，解锁武器和装甲定制
1 个月前
By DDD
<🎜>：死铁路 - 如何完成所有挑战
3 周前
By DDD
热工具
记事本++7.3.1
好用且免费的代码编辑器
SublimeText3汉化版
中文版，非常好用
禅工作室 13.0.1
功能强大的PHP集成开发环境
Dreamweaver CS6
视觉化网页开发工具
SublimeText3 Mac版
神级代码编辑软件(SublimeText3)
热门话题
Go WebSocket 消息如何发送？
Jun 03, 2024 pm 04:53 PM
在Go中，可以使用gorilla/websocket包发送WebSocket消息。具体步骤：建立WebSocket连接。发送文本消息：调用WriteMessage(websocket.TextMessage,[]byte("消息"))。发送二进制消息：调用WriteMessage(websocket.BinaryMessage,[]byte{1,2,3})。
深入理解 Golang 函数生命周期与变量作用域
Apr 19, 2024 am 11:42 AM
在Go中，函数生命周期包括定义、加载、链接、初始化、调用和返回；变量作用域分为函数级和块级，函数内的变量在内部可见，而块内的变量仅在块内可见。
如何在 Go 中使用正则表达式匹配时间戳？
Jun 02, 2024 am 09:00 AM
在Go中，可以使用正则表达式匹配时间戳：编译正则表达式字符串，例如用于匹配ISO8601时间戳的表达式：^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-][0-9]{2}:[0-9]{2})$。使用regexp.MatchString函数检查字符串是否与正则表达式匹配。
Golang 与 Go 语言的区别
May 31, 2024 pm 08:10 PM
Go和Go语言是不同的实体，具有不同的特性。Go（又称Golang）以其并发性、编译速度快、内存管理和跨平台优点而闻名。Go语言的缺点包括生态系统不如其他语言丰富、语法更严格以及缺乏动态类型。
Golang 技术性能优化中如何避免内存泄漏？
Jun 04, 2024 pm 12:27 PM
内存泄漏会导致Go程序内存不断增加，可通过：关闭不再使用的资源，如文件、网络连接和数据库连接。使用弱引用防止内存泄漏，当对象不再被强引用时将其作为垃圾回收目标。利用go协程，协程栈内存会在退出时自动释放，避免内存泄漏。
如何在 IDE 中查看 Golang 函数文档？
Apr 18, 2024 pm 03:06 PM
使用IDE查看Go函数文档：将光标悬停在函数名称上。按下热键（GoLand：Ctrl+Q；VSCode：安装GoExtensionPack后，F1并选择"Go:ShowDocumentation"）。
Go 并发函数的单元测试指南
May 03, 2024 am 10:54 AM
对并发函数进行单元测试至关重要，因为这有助于确保其在并发环境中的正确行为。测试并发函数时必须考虑互斥、同步和隔离等基本原理。可以通过模拟、测试竞争条件和验证结果等方法对并发函数进行单元测试。
Golang 函数接收 map 参数时的注意事项
Jun 04, 2024 am 10:31 AM
在Go中传递map给函数时，默认会创建副本，对副本的修改不影响原map。如果需要修改原始map，可通过指针传递。空map需小心处理，因为技术上是nil指针，传递空map给期望非空map的函数会发生错误。
