Go Concurrency

已于 2022-11-08 13:18:39 修改
阅读量211 收藏
点赞数 1
文章标签： golang
于 2022-07-27 14:03:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ftell/article/details/126003843
版权

1. goroutine

goroutine 是由 Go runtime 管理的轻量级线程。goroutine 非常高效，即使在程序里创建上千个 gorountine 都是可行的。但并非 goroutine 数量越多 app 性能越好，因为最终会受到 CPU 的限制。

2. WaitGroup

以下的 code 有 3 个 goroutine： 一个 main 和两个 count goroutine，现在的问题是，count goroutine 看起来没有执行，因为 main goroutine 启动两个 count goroutine 后，由于没有其他语句，所以立即结束。而对于Go，一旦 main goroutine 退出，整个程序立即结束，是否有其他 goroutine 在跑无关紧要，这些 goroutine 将没有时间做任何事情。

package main

import (
	"fmt"
	"time"
)

func main() {
	go count("sheep")
	go count("fish")
}

func count(thing string) {
	for i:=1;true;i++ {
		fmt.Println(i, thing)
		time.Sleep(time.Millisecond * 500)
	}
}

为了解决 main goroutine 过早退出的问题，可以在 main 里加 time.Sleep(time.Seconde * 3) 或者 fmt.Scanln() 这样的语句，但更好的方法是使用 WaitGroup, WaitGroup 有一个counter，用以统计正在等待的 goroutine 的数量，初值为 0，Add(1) 增加计数，Add(1) 必须在启动 goroutine 之前执行，Done() 减小计数。

package main

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

func main() {
	var wg sync.WaitGroup
	wg.Add(1)   //wg has a counter, counter += 1

	go func() {
		count("sheep")
		wg.Done()   // counter -= 1
	}()
		wg.Wait()   // block，直到 counter 为 0. 如果有任何 goroutine 未结束，将等待。
}

func count(thing string) {
	for i := 1; i <= 5; i++ {
		fmt.Println(i, thing)
		time.Sleep(time.Millisecond * 500)
	}
}

比起 WaitGroup，channel 更为有用。

3. channel

channel 用于 goroutine 之间互相通信，发送给 channel 的可以是任意类型的数据，即使是 channel 类型都可以。

重要，通道的发送和接收都是阻塞操作

当试图接收数据时，必须等待，直到 channel 里有用于读取的值出现，当试图发送数据时，同样必须等待，直到 receiver 准备好接收。

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("program started")
	c := make(chan string)
	go count("sheep", c)

	msg := <-c
	fmt.Println(msg)
}

func count(thing string, c chan string) {
	for i := 1; i <= 5; i++ {
		time.Sleep(time.Millisecond * 5000)
		c <- thing
		time.Sleep(time.Millisecond * 8998886000)  // no effect
	}
}

通道阻塞的特性，使得可以同步各个 goroutine
在这里插入图片描述

3.1 使用 close() 语句关闭通道

以下的代码，虽然能运行出结果，但 Go 在运行时检测到死锁：

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan string)
	go count("sheep", c)

	for {
		msg := <-c
		fmt.Println(msg)
	}
}

func count(thing string, c chan string) {
	for i := 1; i <= 5; i++ {
		c <- thing
		time.Sleep(time.Millisecond * 500)
	}
}

死锁出现的原因是，发送方在发送5次数据后，循环结束，不再发送数据，但接收方仍在等待不可能获得的数据，因而出现死锁。运行结果如下：

sheep
sheep
sheep
sheep
sheep
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
	/tmp/sandbox621737862/prog.go:15 +0x7f

Program exited.

如果发送方已经结束数据发送，不再需要通道时，可以将其关闭。
与之相反，接收方任何时候都不应关闭通道，因为接收方无法得知发送方是否已经结束数据发送，接收方过早关闭通道，将导致异常。

为了解决此死锁的问题，发送方使用 close() 语句关闭通道，接收方会检测通道是否关闭：

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan string)
	go count("sheep", c)

	for {
		msg, open := <-c    // open: 通道是否依然打开
		if !open {    // 如果通道关闭，退出循环
			break
		}
		fmt.Println(msg)
	}
}

func count(thing string, c chan string) {
	for i := 1; i <= 5; i++ {
		c <- thing
		time.Sleep(time.Millisecond * 500)
	} 
	close(c)
}

使用 语法糖, main 中的 for 循环可以简化：

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan string)
	go count("sheep", c)

	for msg := range c {   // 持续从通道接收数据，将其放到 msg 变量中，直至通道关闭
		fmt.Println(msg)
	}
}

func count(thing string, c chan string) {
	for i := 1; i <= 5; i++ {
		c <- thing
		time.Sleep(time.Millisecond * 500)
	} 
	close(c)
}

如下只有几行的代码同样会出现死锁：

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

func main() {
	c := make(chan string)
	c <- "hello"

	msg := <-c
	fmt.Println(msg)
}

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
	/tmp/sandbox222398587/prog.go:9 +0x37

Program exited.

因为发送会阻塞，直到接收方准备好接收。而代码到不了接收的行 msg := <-c，因为 c <- "hello" 阻塞，为了使这段代码能 work，应该将发送放到 goroutine 中，另一种可选的做法是，将 channel 设置为 buffered channel。

4. buffered channel 缓冲通道

通道默认都是 unbuffered 即无缓冲的，强制要求通道的发送方和接收方同时完成发送和接收，如果无法做到就阻塞等待，无缓冲通道用于实现 goroutine 之间的同步通信。而缓冲通道允许接收一定数量的数据，不要求都有对应的接收者，仅当通道满了，即数据的数量已达到指定的 capacity 时才阻塞。

package main

import "fmt"

func main() {
	c := make(chan string, 2)  
	c <- "hello"
	c <- "world"

	msg := <-c
	fmt.Println(msg)

	msg = <-c
	fmt.Println(msg)
}

输出：

PS D:\temp\go_test> go run main.go
hello
world

通道 (或者：无缓冲通道)
在这里插入图片描述
缓冲通道
在这里插入图片描述

5. 为什么使用 select

如下的代码效率不高：

package main

import (
	"fmt"
	"time"
)

func main() {
	c1 := make(chan string)
	c2 := make(chan string)

	go func() {
		for {
			c1 <- "Every 500ms"
			time.Sleep(time.Millisecond * 500)
		}
	}()

	go func() {
		for {
			c2 <- "Every 2s"
			time.Sleep(time.Second * 2)
		}
	}()

	for {
		fmt.Println(<-c1)
		fmt.Println(<-c2)
	}
}

后面的输出，总是等待2秒后，c1, c2 中的数据一起输出：

Every 500ms
Every 2s
Every 500ms
Every 2s
Every 500ms
Every 2s
Every 500ms

如果改成 select：

package main

import (
	"fmt"
	"time"
)

func main() {
	c1 := make(chan string)
	c2 := make(chan string)

	go func() {
		for {
			c1 <- "Every 500ms"
			time.Sleep(time.Millisecond * 500)
		}
	}()

	go func() {
		for {
			c2 <- "Every 2s"
			time.Sleep(time.Second * 2)
		}
	}()

	for {
		select {
			case msg1 := <-c1:
				fmt.Println(msg1)
			case msg2 := <-c2:
				fmt.Println(msg2)
		}
	}
}

运行结果：

Every 2s
Every 500ms
Every 500ms
Every 500ms
Every 500ms
Every 2s
Every 500ms
Every 500ms
Every 500ms
Every 500ms
Every 2s

select 的作用：哪个 channel ready 就从哪个 channel 接收数据，从而减少不必要的等待时间。

6. 一种常见的模式：worker pool

以下的代码计算 fibonacci 数，如果使用 单个 goroutine:

package main

import "fmt"
import "time"

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

	jobs := make(chan int, 100)
	results := make(chan int, 100)
	go worker(jobs, results)
	
	for i := 0; i < 45; i++ {
		jobs <- i
	}
	close(jobs)
	for j := 0; j < 45; j++ {
		fmt.Println(<-results)
	}
	elapsed := time.Since(start)
	fmt.Println("---", elapsed)
}

func worker(jobs <-chan int, results chan<- int) {
	for n := range jobs {
		results <- fib(n)
	}
}

func fib(n int) int {
	if n <= 1 {
		return n
	}
	return fib(n-1) + fib(n-2)
}

运行结果：

0
1
1
2
3
..............
46368
433494437
701408733
--- 8.5861279s

运行时间长，CPU 的利用率不高：
在这里插入图片描述

但是如果增加 worker goroutine 的数目：

jobs := make(chan int, 100)
	results := make(chan int, 100)
	go worker(jobs, results)
	go worker(jobs, results)
	go worker(jobs, results)
	go worker(jobs, results)
	go worker(jobs, results)
	go worker(jobs, results)
	go worker(jobs, results)
	go worker(jobs, results)
	for i := 0; i < 45; i++ {
		jobs <- i
	}

以上的 worker goroutine 是随意加的，所需时间缩短了将近4s，，缺点就是输出结果无序。

0
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765
10946
17711
28657
2
3
46368
1
121393
75025
5
196418
317811
267914296
433494437
701408733
--- 3.7104683s

CPU 利用率增加
在这里插入图片描述
使用 worker pool，一定程度上将能提高程序的 performance

油罐笔记：Concurrency in Go
https://www.youtube.com/watch?v=LvgVSSpwND8
https://stackoverflow.com/questions/25795131/do-buffered-channels-maintain-order

小公鸡卡哇伊呀~
关注
Go并发concurrency
冷月醉雪的博客
11-09 534
并发concurrency  很多人都是冲着Go大肆宣扬的高并发而忍不住跃跃欲试，但其实从源码的解析来看，goroutine只是官方实现的超级“线程池”而已。不过话说回来，每个实例4-5KB的栈内存占用和由于实现机制而大幅减少的创建和销毁开销，是制造Go号称高并发的根本原因。另外，goroutine的简单易用，也在语言层面上给予了开发者巨大的便利。 并发不是并行： 并发主要由切换时间片来...
Go_Concurrency_Patterns.pdf
02-17
Go_Concurrency_Patterns
Go 的并发 Concurrency
Ghost_02的博客
08-09 1532
Go 的并发               很多人都是冲着Go的高并发来学习Go的。而gorouting只是由官方实现的一个超级线程池而已，每个实例4-5KB的栈内存占用和由于实现机制而大幅减少创建和销毁的开销。这就是Go高并发的原因。      Go中并发程序依靠的是两个：goroutine和channel。      一个goroutine对新手来说可看作一个线程，但是他又不是一个
[11][go] go concurrency
WhateverYoung的专栏
02-03 237
绝妙的 CHANNEL channel1 channel提供了一种强大的、在不使用锁或临界区的情况下，从某个 goroutine 向其他 goroutine 发送数据流的方法。 发送者才能关闭channel 一个已经被关闭的 channel 永远都不会阻塞 已经被关闭的 channel。当一个 channel 一旦被关闭，就不能再向这个 channel 发送数据，不过你仍然可以尝试从 cha...
Go Concurrency .pptx
09-20
根据提供的文件信息，我们可以深入探讨Go语言中的并发概念与实践，包括并发与并行的区别、通道（channel）的理解、Go的并发模式等关键知识点。 ### Go并发基础 #### 并发与并行的区别 在讨论Go语言时，很多人首先...
Go Concurrency Patterns_ Pipelines and cancellation - The Go Programming Language
10-26
Go Concurrency Patterns_ Pipelines and cancellation - The Go Programming Language
Advanced_Go_Concurrency_Patterns.rar
02-17
Advanced_Go_Concurrency_Patterns
Concurrency in Go.pdf
02-21
综上所述，《Concurrency in Go》这本书无疑是Go语言并发编程领域的权威指南，为开发者提供了深入学习和掌握Go并发工具和技术的宝贵资源。对于希望深入探索Go并发模型，或者正在寻找提高并发编程技能的开发者而言，...
Concurrency in Go: Tools and Techniques for Developers
08-16
Concurrency in Go: Tools and Techniques for Developers by Katherine Cox-Buday English | 19 July 2017 | ISBN: 1491941197 | ASIN: B0742NH2SG | 240 Pages | AZW3 | 1.15 MB Concurrency can be notoriously difficult to get right, but fortunately, the Go open source programming language makes working with concurrency tractable and even easy. If you’re a developer familiar with Go, this practical book demonstrates best practices and patterns to help you incorporate concurrency into your systems. Author Katherine Cox-Buday takes you step-by-step through the process. You’ll understand how Go chooses to model concurrency, what issues arise from this model, and how you can compose primitives within this model to solve problems. Learn the skills and tooling you need to confidently write and implement concurrent systems of any size. Understand how Go addresses fundamental problems that make concurrency difficult to do correctly Learn the key differences between concurrency and parallelism Dig into the syntax of Go’s memory synchronization primitives Form patterns with these primitives to write maintainable concurrent code Compose patterns into a series of practices that enable you to write large, distributed systems that scale Learn the sophistication behind goroutines and how Go’s runtime stitches everything together
go-concurrency:代码审查清单
03-25
代码审查清单：Go并发 此页面是“ 列表的补充。 该列表的目的是帮助您查看Go代码时发现与并发相关的错误。 您也可以只阅读一次此列表以刷新内存并确保您了解所有这些并发性陷阱。 同步和竞争条件不足 测验 可扩展性 时间 同步和竞争条件不足 RC.1。 HTTP处理程序函数可以安全地从多个goroutine并发调用吗？ 很容易忽略HTTP处理程序应该是线程安全的，因为通常不会从项目代码中的任何地方显式调用HTTP处理程序，而只能从HTTP服务器内部对其进行显式调用。 RC.2。 是否存在一些不受互斥量保护的字段或变量访问，其中该字段或变量是基元或不是显式线程安全的类型（例如atomic.Value ），而可以从并发goroutine更新此字段？ 由于非原子性的硬件写入和潜在的内存可见性问题，即使将读取同步到原始变量也要不同步是不安全的。 另请参见。 RC.3。 线程安
Go Concurrency 实战
weixin_33842328的博客
05-27 120
为什么80%的码农都做不了架构师？>>> ...
GO语言基础进阶教程：并发性Concurrency的概念
qfzhangxu的博客
07-14 339
并发性Concurrency @author：韩茹 版权所有：北京千锋互联科技有限公司 1.1 多任务 怎么来理解多任务呢？其实就是指我们的操作系统可以同时执行多个任务。举个例子，你一边听音乐，一边刷微博，一边聊QQ，一边用Markdown写作业，这就是多任务，至少同时有4个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是界面上没有显示而已。 CPU的速度太快啦。。。 1.2 什么是并发 Go是并发语言，而不是并行语言。在讨论如何在Go中进行并发处理之前，我们首先必须了解什么是并发
Go 并发concurrency 学习笔记
勿忘初心
08-13 1037
很多人都是冲着 Go 大肆宣扬的高并发而忍不住跃跃欲试，但其实从 源码的解析来看，goroutine 只是由官方实现的超级“线程池”而已。 不过话说回来，每个实例 4-5KB 的栈内存占用和由于实现机制而大幅 减少的创建和销毁开销，是制造 Go 号称的高并发的根本原因。另外， goroutine 的简单易用，也在语言层面上给予了开发者巨大的便利。 并发不是并行：Concurrency Is
GO语言学习笔记（十二、并发concurrency）
02-02 231
并发concurrency 很多人都冲着Go大肆宣扬的高并发而忍不住跃跃欲试，但其实从源码的解析来看，goroutine只是由官方实现的超级“线程池”而已。 不过话说回来，每个实例4-5KB的栈内存占用和由于实现机制而大幅减少的创建和销毁开销，是制造Go号称的高并发的根本原因。 另外goroutine的简单易用，也在语言层面上给予了开发者巨大的便利。 并发不是并行：Concurrency ...
Go语言入门（五）Concurrency.
KGRookie的博客
08-06 166
在学习Go语言的入门课程，简单记录一些课程中的内容 在线学习教程https://tour.golang.org/ 第三部分 并发 3.1 协程(Goroutine) goroutine是由Go运行时管理的轻量级线程，使用goroutine来实现并发。 go f(x, y, z) 启动一个新的goroutine运行 f(x, y, z) f、x、y 和 z 的计算发生在当前 goroutine 中，而f的执行发生在新goroutine中。Goroutine 运行在相同的地址空间中，因此.
Go之组件学习-channel（concurrency篇）
qq_41903105的博客
02-04 909
文章目录导语：一、channel的定义二、channel的使用方式三、channel的一些场景四、channel的一些简单场景应用五、channel 一些禁止项文章借鉴 导语： 最近在学习关于go语言的concurrency的channel模块，就看到了ardan labs里面的一些例子，促进理解channel一些原理和使用 一、channel的定义 Channels allow goroutines to communicate with each other through the use of si
探索Go并发编程之美：Go-Concurrency项目解析
最新发布
gitblog_00038的博客
04-03 244
探索Go并发编程之美：Go-Concurrency项目解析 项目地址:https://gitcode.com/wuqinqiang/Go_Concurrency 在这个高效率和多核处理器的时代，利用并发处理任务已成为软件开发的重要策略。Go语言以其独特的并发模型——goroutines和channels，为开发者提供了高效且易于管理并发的强大工具。而今天我们要介绍的项目，Go-Concurrenc...
《Concurrency in Go》阅读笔记 -- 第三章：Go语言并发组件
Shiina_Orez的博客
06-14 1013
《Concurrency in Go》 本章节从goroutine入手，讲解go语言的各种并发原语。在讲解完goroutine之后，对于传统的内存同步访问的并发原语：sync包中的Mutex，RWMutex，Cond，Once，WaitGroup，Pool等进行了分析。在此之后着重讲了go语言的另一大特色：channel。在最后，讲解了如何结合channel的语法：select语句。 插一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值