Go协程goroutine与管道channel
-
-
- [1 协程goroutine](#1 协程goroutine)
-
- [1.1 基本介绍](#1.1 基本介绍)
- [1.2 快速入门](#1.2 快速入门)
- [1.3 调度模型:MPG模式介绍](#1.3 调度模型:MPG模式介绍)
- [1.4 设置cpu数](#1.4 设置cpu数)
- [1.5 协程资源竞争问题](#1.5 协程资源竞争问题)
- [1.6 解决协程并发方案](#1.6 解决协程并发方案)
- [2 管道channel](#2 管道channel)
-
- [2.1 基本介绍](#2.1 基本介绍)
- [2.2 快速入门](#2.2 快速入门)
- [2.3 管道的关闭和遍历](#2.3 管道的关闭和遍历)
- [2.4 管道和协程的结合](#2.4 管道和协程的结合)
- [2.5 声明 只读/只写 的管道](#2.5 声明 只读/只写 的管道)
- [2.6 select解决管道堵塞](#2.6 select解决管道堵塞)
- [2.7 recover解决程序崩溃](#2.7 recover解决程序崩溃)
-
1 协程goroutine
1.1 基本介绍
前置知识:"进程和线程","并发与并行"
- 协程的概念
协程(Coroutine)是一种用户态的轻量级线程,不同于操作系统线程,协程能够在单个线程中实现多任务并发,使用更少的系统资源。协程的运行由程序控制,不需要操作系统介入,因此协程之间的切换更加快速。
- Go语言中的协程
在Go语言中,协程被称为"Goroutine",是一种轻量级的线程。与操作系统线程不同,Go语言的Goroutine只需要几kb的内存,并且可以很容易地创建数千个Goroutine,因为它们由Go运行时(Goruntime)自动管理。
Go协程和Go主线程
- Go主线程 (有程序员直接称为线程 /也可以理解成进程 ):一个Go线程上,可以起多个协程,你可以这样理解,
协程是轻量级的线程[编译器做优化]
。 - Go协程的特点:
- 有独立的栈空间
- 共享程序堆空间
- 调度由用户控制
- 协程是轻量级的线程
1.2 快速入门
案例说明:
- 在主线程(可以理解成进程)中,开启一个goroutine,该协程每隔1秒输出 "hello,world"。
- 在主线程中也每隔一秒输出"hello,golang",输出10次后,退出程序。
- 要求主线程和goroutine同时执行。
go
func test() {
for i := 1; i < 10; i++ {
fmt.Println("协程 test() hello, world" + strconv.Itoa(i))
time.Sleep(time.Second)
}
}
func main() {
// 开启协程
go test()
for i := 1; i < 10; i++ {
fmt.Println("主线程 main() hello, world" + strconv.Itoa(i))
time.Sleep(time.Second)
}
}
输出结果:
go
主线程 main() hello, world1
协程 test() hello, world1
协程 test() hello, world2
主线程 main() hello, world2
主线程 main() hello, world3
协程 test() hello, world3
略。。。
从输出结果就可以看出来,这两个是交替输出的,就是并发执行~
小结:
-
主线程是一个物理线程,直接作用在cpu上的,是重量级的,非常消费cpu资源。
-
协程从主线程开启的,是轻量级的线程,是逻辑态。对资源消耗相对较小。
-
Golang的协程机制是重要的特点,可以轻松的开启上万个协程。其他编程语言的并发机制是一般基于线程的,开启过多的线程,资源消费大,这里就突显Golang在并发上的优势了。
1.3 调度模型:MPG模式介绍
这里只是简单的讲一下,具体可以去网上找找文章
- M:操作系统的主线程(是物理线程)
- P:协程执行需要的上下文(需要的资源等)
- G:协程
状态一:
状态二:
1.4 设置cpu数
介绍:为了充分的利用多cpu的优势,在Golang程序中,设置运行的cpu数目。
使用的函数:func NumCPU
功能:NumCPU返回本地机器的逻辑CPU个数。
函数的代码如下:
func NumCPU() int
使用案例:
go
func main() {
// 获取当前系统cpu的数量
num := runtime.NumCPU()
// 我这里设置num-1的cpu运行go程序
runtime.GOMAXPROCS(num)
fmt.Println("num=", num)
}
输出结果:num= 16
- go 1.8 后,默认让程序运行在多个核上,可以不用设置了。
- go 1.8 前,还是要设置一下,可以更新的利用cpu。
1.5 协程资源竞争问题
**需求:**现在要计算1-200的各个数的阶乘,并且把各个数的阶乘放入到map中。最后显示出来。要求使用goroutine完成。
分析思路:
- 使用goroutine来完成,效率搞,但是会出现并发/并行安全问题。
- 这里就提出了不同goroutine如何通信的问题。
代码实现:
- 使用goroutine来完成(看看使用gorotine并发完成会出现什么问题?然后我们会去解决)
- 在运行某个程序是,如何知道是否存在资源竞争问题。方法很简单,在编译该程序时,增加一个参数 -race即可。
思路
- 编写一个函数,来计算各个数的阶乘,并放入到 map中。
- 我们启动的协程多个,统计的将结果放入到 map中。
- map 应该做出一个全局的。
初步代码:
go
var (
myMap = make(map[int]int, 10)
)
// test 函数就是计算 n!, 让将这个结果放入到 myMap
func test(n int) {
res := 1
for i := 1; i <= n; i++ {
res *= i
}
}
func main() {
// 我们这里开启多个协程完成这个任务[200个]
for i := 1; i <= 20; i++ {
go test(i)
}
//我们输出结果,变量这个
for i, v := range myMap {
fmt.Printf("map[%d]=%d\n", i, v)
}
}
输出结果:无???什么都没有??为啥呢?因为主线程提前结束了,在协程结束前结束了,就什么都没有!!
下一步:我们让主线程休眠10秒钟
添加代码:
go
//休眠10秒钟【第二个问题 】
time.Sleep(time.Second * 5)
再运行,会发现竟然报错了:
也就是报错显示,恐怖错误,并发向协程做了写操作。
为啥?
因为,map是不安全的,也就是,200个线程同时向map里面写操作
,导致并发问题。
所以现在有两个问题:
- map是不安全的,导致并发问题。
- 主线程休眠时间无法确定。
1.6 解决协程并发方案
- 声明一个全局的互斥锁,当第一个线程进行写操作,其他的线程没办法进去操作并且进入一个队列(数据结构)进行排队。
go
var (
myMap = make(map[int]int, 10)
//声明一个全局的互斥锁
//lock 是一个全局的互斥锁,
//sync 是包: synchornized 同步
//Mutex : 是互斥
lock sync.Mutex
)
func test(n int) {
res := 1
for i := 1; i <= n; i++ {
res *= i
}
//这里我们将 res 放入到myMap
//加锁
lock.Lock()
myMap[n] = res //concurrent map writes?
//解锁
lock.Unlock()
}
func main() {
// 我们这里开启多个协程完成这个任务[200个]
for i := 1; i <= 20; i++ {
go test(i)
}
//这里我们输出结果,变量这个结果
lock.Lock()
for i, v := range myMap {
fmt.Printf("map[%d]=%d\n", i, v)
}
lock.Unlock()
}
输出结果:会发现没有问题~~
2 管道channel
虽然上面的方式解决了这个问题,但是不够完美,包括官方也说了,加锁是比较低级的做法,所以就引出了管道。
为什么需要channel
-
前面使用全局变量加锁同步来解决goroutine的通讯,但不完美
-
主线程在等待所有goroutine全部完成的时间很难确定,我们这里设置10秒,仅仅是估算。
-
如果主线程休眠时间长了,会加长等待时间,如果等待时间短了,可能还有goroutine处于工作状态,这时也会随主线程的退出而销毁
-
通过全局变量加锁同步来实现通讯,也并不利用多个协程对全局变量的读写操作。
-
上面种种分析都在呼唤一个新的通讯机制-channel
2.1 基本介绍
- chanel 本质就是一个数据结构-队列
- 数据是先进先出【FIFO】
- 线程安全,多goroutine 访问时,不需要加锁,就是说channel 本身就是线程安全的。
- channel 有类型的,一个 string 的channel 只能存放string类型数据。
2.2 快速入门
定义/声明channel
go
var 变量名 chen 数据类型
说明:
- channel是引用类型
- channel必须初始化才能写入数据,即make后才能使用。
- 管道是有类型的,intChan 只能写入整数int
案例入门:
go
func main() {
//演示一下管道的使用
//1. 创建一个可以存放3个int类型的管道
var intChan chan int
intChan = make(chan int, 3)
//2. 看看intChan是什么
fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)
}
输出结果:
go
intChan 的值=0xc000014700 intChan本身的地址=0xc00005e020
下面我们试一下向管道写入数据和读取数据
go
func main() {
//演示一下管道的使用
//1. 创建一个可以存放3个int类型的管道
var intChan chan int
intChan = make(chan int, 3)
//2. 看看intChan是什么
fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)
//3. 向管道写入数据
intChan<- 10
num := 211
intChan<- num
intChan<- 50
// //如果从channel取出数据后,可以继续放入
<-intChan
intChan<- 98//注意点, 当我们给管写入数据时,不能超过其容量
//4. 看看管道的长度和cap(容量)
fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 3, 3
//5. 从管道中读取数据
var num2 int
num2 = <-intChan
fmt.Println("num2=", num2)
fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 2, 3
//6. 在没有使用协程的情况下,如果我们的管道数据已经全部取出,再取就会报告 deadlock
num3 := <-intChan
num4 := <-intChan
//num5 := <-intChan
fmt.Println("num3=", num3, "num4=", num4/*, "num5=", num5*/)
}
输出结构:
go
intChan 的值=0xc000014700 intChan本身的地址=0xc00005e020
channel len= 3 cap=3
num2= 211
channel len= 2 cap=3
num3= 50 num4= 98
2.3 管道的关闭和遍历
channel的关闭
使用内置函数close可以关闭chanel,当channel关闭后,就不能再向channel写数据了,但是仍让可以从该channel读数据。
channel的遍历
channel支持for-range的方式进行遍历,请注意两个心结
- 在遍历时,如果channel没有关闭,则会出现deadlock的错误。
- 在遍历时,如果channel已经关闭,则会正常遍历数据,遍历完后,就会退出遍历。
代码演示:
go
func main() {
intChan := make(chan int, 3)
intChan <- 100
intChan <- 200
close(intChan) // close
//这是不能够再写入数到channel
//intChan<- 300
fmt.Println("okook~")
//当管道关闭后,读取数据是可以的
n1 := <-intChan
fmt.Println("n1=", n1)
//遍历管道
intChan2 := make(chan int, 100)
for i := 0; i < 10; i++ {
intChan2 <- i * 2 //放入10个数据到管道
}
//遍历管道不能使用普通的 for 循环
// for i := 0; i < len(intChan2); i++ {
// }
//在遍历时,如果channel没有关闭,则会出现deadlock的错误
//在遍历时,如果channel已经关闭,则会正常遍历数据,遍历完后,就会退出遍历
close(intChan2)
for v := range intChan2 {
fmt.Println("v=", v)
}
}
输出结果:
go
okook~
n1= 100
v= 0
v= 2
v= 4
v= 6
后面略~~~
2.4 管道和协程的结合
需求:
要求统计 1-80000 的数字中,哪些是素数?
下面是思路分析图:
- 创建一个管道intChan,用来存这8000个数,设置容量1000
- 创建一个协程,将1到8000放到这个inChan管道里
- 创建一个管道primeChan,用来储存素数,只要是素数都存进来
- 创建四个协程,从inChan管道里取数,并计算受否为素数,如果是素数就放到primeChan里
- 那怎么确认协程传输完毕,然后把管道关掉?
- 创建一个管道exitChan,这里是四个协程,那就容量为4
- 当这四个协程取不到数的时候,就会向exitChan管道,传一个True,表示结束
- 主线程进行一个循环取exitChan,当取出来的数达到四个的时候,就关闭,这两个管道
go
package main
import (
"fmt"
"time"
)
// 向 intChan放入 1-100个数
func putNum(intChan chan int) {
for i := 1; i <= 100; i++ {
intChan <- i
}
//关闭intChan
close(intChan)
}
// 从 intChan取出数据,并判断是否为素数,如果是,就
//
// //放入到primeChan
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
//使用for 循环
// var num int
var flag bool //
for {
//time.Sleep(time.Millisecond * 10)
num, ok := <-intChan //intChan 取不到..
if !ok {
break
}
flag = true //假设是素数
//判断num是不是素数
for i := 2; i < num; i++ {
if num%i == 0 { //说明该num不是素数
flag = false
break
}
}
if flag {
//将这个数就放入到primeChan
primeChan <- num
}
}
fmt.Println("有一个primeNum 协程因为取不到数据,退出")
//这里我们还不能关闭 primeChan
//向 exitChan 写入true
exitChan <- true
}
func main() {
intChan := make(chan int, 100)
primeChan := make(chan int, 100) //放入结果
//标识退出的管道
exitChan := make(chan bool, 8) // 4个
start := time.Now().Unix()
//开启一个协程,向 intChan放入 1-8000个数
go putNum(intChan)
//开启4个协程,从 intChan取出数据,并判断是否为素数,如果是,就
//放入到primeChan
for i := 0; i < 8; i++ {
go primeNum(intChan, primeChan, exitChan)
}
//这里我们主线程,进行处理
//直接
go func() {
for i := 0; i < 8; i++ {
<-exitChan
}
end := time.Now().Unix()
fmt.Println("使用协程耗时=", end-start)
//当我们从exitChan 取出了4个结果,就可以放心的关闭 prprimeChan
close(primeChan)
}()
res := make([]int, 0)
//遍历我们的 primeChan ,把结果取出
for {
data, ok := <-primeChan
if !ok {
break
}
res = append(res, data)
}
fmt.Printf("100的素数有: %v个,分别是:%v \n", len(res), res)
fmt.Println("main线程退出")
}
输出结果:
go
有一个primeNum 协程因为取不到数据,退出
有一个primeNum 协程因为取不到数据,退出
有一个primeNum 协程因为取不到数据,退出
有一个primeNum 协程因为取不到数据,退出
有一个primeNum 协程因为取不到数据,退出
有一个primeNum 协程因为取不到数据,退出
有一个primeNum 协程因为取不到数据,退出
有一个primeNum 协程因为取不到数据,退出
使用协程耗时= 0
100的素数有: 26个,分别是:[1 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97]
main线程退出
补充:这里用了一个记录协程消耗时间的方法
go
start := time.Now().Unix()
end := time.Now().Unix()
fmt.Println("使用协程耗时=", end-start)
补充知识:管道阻塞
在使用channel通道进行数据传递时,接收方从通道中获取数据的操作可以是阻塞的。具体来说,有以下几种情况会导致接收方的操作阻塞:
- 通道中没有可用的数据:当接收方尝试从一个没有数据的通道中获取数据时,它将被阻塞,等待通道中有数据可供接收。
- 通道中没有发送者:如果通道已经关闭,并且没有任何Goroutine发送数据到该通道,接收方将永久地阻塞在接收操作中。
- 通道中发送数据速度过慢:如果接收方的处理速度快于发送方的发送速度,那么接收方在获取到一条数据后,等待一段时间后可能会发现再次从通道中获取的数据仍然不可用,因此接收方将再次被阻塞。
- 管道未关闭进行遍历操作:在遍历通道时,如果通道没有被关闭,并且发送方没有向通道发送数据,接收方的遍历操作会被阻塞。
需要注意的是,当通道被阻塞时,程序的执行仍然会继续,只是被阻塞的Goroutine会暂停执行,直到满足接收操作的条件。
2.5 声明 只读/只写 的管道
channel可以声明为只读,或者只写性质。
go
var chan1 chan<- int // 声明为只写
var chan2 <-chan int// 声明为只写
注意:如果在一个协程里传入了一个管道,并且设置它只读只写,那么,因为作用域,就只在这个协程里面是属于只读只写的情况,可以防止一下误操作。
2.6 select解决管道堵塞
使用select可以解决从管道取数据的阻塞问题
案例代码,自学理解:
go
func main() {
//使用select可以解决从管道取数据的阻塞问题
//1.定义一个管道 10个数据int
intChan := make(chan int, 10)
for i := 0; i < 10; i++ {
intChan <- i
}
//2.定义一个管道 5个数据string
stringChan := make(chan string, 5)
for i := 0; i < 5; i++ {
stringChan <- "hello" + fmt.Sprintf("%d", i)
}
//传统的方法在遍历管道时,如果不关闭会阻塞而导致 deadlock
//问题,在实际开发中,可能我们不好确定什么关闭该管道.
//可以使用select 方式可以解决
//label:
for {
select {
//注意: 这里,如果intChan一直没有关闭,不会一直阻塞而deadlock
//,会自动到下一个case匹配
case v := <-intChan:
fmt.Printf("从intChan读取的数据%d\n", v)
time.Sleep(time.Second)
case v := <-stringChan:
fmt.Printf("从stringChan读取的数据%s\n", v)
time.Sleep(time.Second)
default:
fmt.Printf("都取不到了,不玩了, 程序员可以加入逻辑\n")
time.Sleep(time.Second)
return
//break label
}
}
}
这样就能够解决啦~~~
2.7 recover解决程序崩溃
**说明:**如果我们起了一个协程,但是这个协程出现了panic,如果我们没有捕获这个panic,就会早晨整个程序崩溃,这时我,1可以砸爱goroutine中使用recover来捕获panic,进行处理,这样即使这个协程发生了问题,但是主线程仍然不受影响,可以继续执行。
go
// 函数
func sayHello() {
for i := 0; i < 10; i++ {
time.Sleep(time.Second)
fmt.Println("hello,world")
}
}
// 函数
func test() {
//这里我们可以使用defer + recover
defer func() {
//捕获test抛出的panic
if err := recover(); err != nil {
fmt.Println("test() 发生错误", err)
}
}()
//定义了一个map
var myMap map[int]string
myMap[0] = "golang" //error
}
func main() {
go sayHello()
go test()
for i := 0; i < 10; i++ {
fmt.Println("main() ok=", i)
time.Sleep(time.Second)
}
}
输出结果:
go
main() ok= 0
test() 发生错误 assignment to entry in nil map
main() ok= 1
hello,world
hello,world
main() ok= 2
略~~~
Over!!!!坚持就是胜利!!兄弟们!!!冲冲冲!!!