Go_协程与管道
协程（goroutine）
基本介绍
- 进程和线程的关系；
- 进程是系统进行资源分配和调度的基本单位
- 一个进程可以有多个线程
- 同一个进程的多个线程并发的执行
- 并发和并行
- 多线程程序在单核上进行，就是并发
- 多线程程序在多核上运行，就是并行
Go协程和Go主线程
- Go主线程（有的程序员直接称为 线程/也可理解成进程）：一个Go线程上，可以起多个协程，协程是轻量级的线程【编译器做了优化】
- Go协程的特点：
- 有独立的栈空间
- 共享程序堆空间
- 调度由用户控制
- 协程是轻量级的线程
协程快速入门
- 案例：请编写一个程序，完成如下功能
- 在主线程中，开启一个goroutine，该协程每隔1秒输出“hello，world”
- 在主线程中也每隔一秒输出“hello，golang”，输出10次后，退出程序
- 要求主线程和goroutine同时执行
- 画出主线程和协程执行流程图
- 代码和运行结果
- 执行流程图
- 小结：
- 主线程是一个物理线程，直接作用在CPU上的，是重量级的，非常耗费CPU资源。
- 协程从主线程开启的，是轻量级的线程，是逻辑态，对资源消耗相对小
- Golang的协程机制是重要的特点，可以轻松开启上万个协程。其他编程语言的并发机制一般是基于线程的，开启过多线程，资源耗费大
goroutine 调度模型（MPG）
- M：操作系统的主线程（是物理线程）
- P：协程执行需要的上下文环境，是实现从N：1到N：M映射的关键
- G：协程
runtime包
设置Golang运行的CPU数
- 运用到的runtime包中的方法
- func NumCPU() int：返回本地机器的逻辑CPU个数
- func GOMAXPROCS(n int) int：设置可同时执行的最大CPU数，并返回先前的设置。
- go1.8后，默认让程序运行在多个核上，可以不用设置；之前的版本，可以设置一下，可让CPU利用率更高效
package main
import (
"fmt"
"runtime"
)
func main(){
//获取当前系统CPU的数量
cpuNum := runtime.NumCPU()
fmt.Println("cpuNum=", cpuNum)
//可以自己设置使用多少个CPU
runtime.GOMAXPROCS(cpuNum - 1)
fmt.Println("ok")
}
管道（channel）
引入
- 需求：现要计算1-200的各个数的阶乘，并且把各个数的阶乘放入到map中。最后显示出来。要求使用goroutine完成
- 代码实现与问题发现：
- 上述代码，需求中，存在多个协程向同一块map空间中写数据的操作
- 资源竞争命令：1）go build -race main.go；2）main.exe
解决方法
不同goroutine之间如何通信：
1）全局变量的互斥锁
使用了sync包：sync包提供了基本的同步基元，如互斥锁。大部分都是适用于低水平程序线程，高水平的同步使用channel通信更好一些。
代码改进：
缺点：
- 主线程在等待所有goroutine全部完成时间是很难确定的
- 通过全局变量加锁同步来实现通讯，也并不利于多个协程对全局变量的读写操作
-2） 管道（channel）
- channel的本质就是数据结构—队列
- 线程安全，多goroutine访问时，不需要加锁；
- channel是有类型的，一个string的channel只能存放string类型数据
channel的定义/声明
1. 定义/声明 channel
- 代码示例：
package main
import (
"fmt"
)
func main(){
//演示管道的使用
//创建一个可以存放3个int类型的管道
var intChan chan int
intChan = make(chan int, 3)
//看看channel是什么
fmt.Printf("intChan的值=%v intChan本身的地址=%p\n", intChan, &intChan)
//向管道写入数据
intChan<- 10
num := 211
intChan<- num
//看看管道的长度和容量;管道的容量分配内存时已经确定，不会动态增长
fmt.Printf("intChan的长度=%v 容量=%v \n", len(intChan), cap(intChan))
//从管道中取数据
var num2 int
num2 = <-intChan
fmt.Println("num2=", num2)
//观察管道的长度，容量
fmt.Printf("intChan的长度=%v 容量=%v \n", len(intChan), cap(intChan))
//在没有使用协程的情况下，若管道中的数据已经全部取出，再取就会报告 deadlock
}
- 运行结果：
2. 案例演示
注意
- 上图划红线的地方，编译不通过；
- 纠正代码如下：
channel的遍历与关闭
1. channel关闭：使用内置函数close
package main
import (
"fmt"
)
func main(){
intChan := make(chan int, 3)
intChan<- 10
intChan<- 20
//关闭channel
close(intChan)
//此时不能在写入数据，但是可以读取
num := <- intChan
fmt.Println("num", num)
}
2. channel遍历：使用for-range方式
- 在遍历时，如果channel没有关闭，则会出现deadlock的错误
- 在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后，就会退出遍历
package main
import (
"fmt"
)
func main(){
intChan := make(chan int, 3)
intChan<- 10
intChan<- 20
//关闭channel
close(intChan)
//此时不能在写入数据，但是可以读取
num := <- intChan
fmt.Println("num", num)
//遍历管道
intChan2 := make(chan int, 20)
for i := 0; i < 20; i++{
intChan2<- i*2 //放入20个数据到channel中
}
//遍历管道不能使用普通for循环
/*在遍历时，没有关闭管道，会遍历输出，
但会出现fatal error: all goroutines are asleep - deadlock!*/
close(intChan2)
for v := range intChan2{
fmt.Println("v=", v)
}
}
goroutine 和channel结合
思路分析：
代码实现：
package main
import (
"fmt"
)
func WriteData(intChan chan int){
for i := 1; i <= 50; i++{
intChan<- i
fmt.Println("写入数据", i)
}
close(intChan)
}
func ReadData(intChan chan int, exitChan chan bool){
for{
v, ok := <-intChan
if !ok{
break
}
fmt.Println("读取的数据", v)
}
exitChan<- true
close(exitChan)
}
func main(){
//创建两个协程
intChan := make(chan int, 50)
exitChan := make(chan bool, 1)
go WriteData(intChan)
go ReadData(intChan, exitChan)
for{
_, ok := <-exitChan
if !ok{
break
}
}
}
代码实现：
package main
import (
"fmt"
)
func putNum(intChan chan int){
for i := 1; i <= 8000; i++{
intChan<-i
}
close(intChan)
}
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool){
for{
num, ok := <-intChan
if !ok{
break
}
var flag = true //假定为素数
//判断num是否为素数
for i := 2; i < num; i++{
if num % i == 0{
flag = false
break
}
}
if flag{
primeChan<- num
}
}
exitChan<- true
fmt.Println("有一个协程已经走完了")
}
//统计1-8000中的素数个数
func main(){
//声明管道
intChan := make(chan int, 1000)
primeChan := make(chan int, 4000) //放素数结果
exitChan := make(chan bool, 4) //标识退出的管道
//开启一个协程putNum，向 intChan中放1-8000个数
start := time.Now().Unix()
go putNum(intChan)
//开启4个协程primeNum，从intChan中取出数据，并判断是否为素数
//如果是，就将其放入primeChan管道中
for i := 0; i < 4; i++{
go primeNum(intChan, primeChan, exitChan)
}
//另开起一个协程，用于判断是否上述4个primeNum协程已经运行完
go func(){
for i := 0; i < 4; i++{
<-exitChan
}
end := time.Now().Unix()
fmt.Println("使用协程耗时=", end - start)
//当从exitChan中取出4个值后，说明primeNum协程已经全部结束
//此时可以关闭primeChan管道
close(primeChan)
}()
//遍历取出结果
for{
res, ok := <-primeChan
if !ok{
break
}
//将结果输出
fmt.Println("是素数的有：", res)
}
}
channel使用注意事项
- channel可以声明为只读，或者只写性质
package main
imoprt (
"fmt"
)
func main(){
//管道可以只声明为只读 或者 只写
var intChan chan int //双向管道，可读可写
var intChan2 chan<- int //只能写
var intChan3 <-chan int //只能读
intChan2 = make(chan int, 2)
intChan3 = make(chan int, 5)
}
- 使用select可以解决从管道取数据的阻塞问题
package main
import (
"fmt"
)
func main(){
//使用select可以解决从管道取数据的阻塞问题
intChan := make(chan int, 10)
for i := 0; i < 10; i++{
intChan<-i
}
stringChan := make(chan string, 5)
for i := 0; i< 5; i++{
stringChan<- "hello" + fmt.Sprintf("%d", i)
}
//传统的方法在遍历管道时，如果不关闭会阻塞导致 deadlock
//而在实际开发中，存在不好确定什么时候关闭管道
//使用select方式解决上述问题
//label:
for{
select{
case v := <-intChan:
fmt.Printf("从intChan读取的数据%d\n", v)
case v := <-stringChan:
fmt.Printf("从stringChan读取的数据%s\n", v)
default:
fmt.Printf("都取不到数据\n")
return
//break label
}
}
}
- goroutine中使用recover，解决协程中出现panic，导致程序崩溃的问题
- 说明：若起了一个协程，但是协程出现了panic；若没有捕获这个panic，就会造成整个程序崩溃。这时我们可以在goroutine中使用recover来捕获panic进行处理。这样即使这个协程发生问题，但是主线程仍然不受影响，可以继续执行。
package main
import (
"fmt"
"time"
)
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" //此处发生错误
}
func main(){
go sayHello()
go test()
time.Sleep(time.Second * 20)
}