1，goroutine-看一个需求
需求：要求统计1-90000000000的数字中，哪些是素数哦？
分析思路：
1）传统的方法，就是使用一个循环，循环的判断各个数是不是素数。
2）使用并发或者并行的方式，将统计素数的任务分配给多个goroutine去完成，这时就会用到goroutine
2，goroutine-基本介绍
2.1进程和线程介绍
2.2程序，进程和线程的关系示意图
2.3并发和执行
并发和并行
1）多线程程序在单核上运行就是并发
2）多线程程序在多核上运行就是并行
3）图示：
并发：一个cpu同时执行多个线程
并行：多个cpu上执行多个线程，就相当于一个cpu执行一个线程
2.4GO协程核GO主线程
GO主线程（有程序员直接称为线程/也可以理解为进程）：一个GO线程上，可以有多个协程，你可以理解为协程是轻量级的线程[编译器做的优化]
GO协程的特点
1）有独立的栈空间
2）共享程序堆空间
3）调度由用户控制
4）协程是轻量级的线程
3，goroutine-简单例子
3.1案例说明
请编写一个程序，完成如下功能
1）在主线程（可以理解成进程)中，开启一个goroutine，该协程每隔一秒输出一次helloworld“
2）在主线程中也每隔一秒输出”hellogolang“，输出10次后，退出程序
3）要求主线程和goroutine同时执行
4）画出主线程和协程的执行流程图
主线程和协程执行流程图
3.2小结
1）主线程是一个物理线程，直接作用在cpu上。是重量级的，非常耗费cpu资源
2）协程从主线程开启，是轻量级的线程，是逻辑态。对资源的耗费相对较小
3）golang的协程机制是重要的特点，可以轻松的开启上万个协程。其他语言的并发机制是一般基于线程的，开启过多的线程耗费资源大，这里就凸显出golang的优势了
4，goroutine的调度模型
4.1MPG模式基本介绍
1）M：操作系统的主线程（是物理线程）
2）P：协程执行需要的上下文
3）G：协程
4.2MPG模式运行的状态1
1）当前程序有三个M，如果三个M都在一个CPU运行，就是并发，如果在不同的CPU下运行就并行
2）M1,M2,M3正在执行一个G，M1的协程队列有三个，M2的协程队列有三个，M3的协程队列有两个
3）从上图可以看出：GO的协程是轻量级的线程，是逻辑态的，GO可以容易起上万个协程
4）其他程序c/java的多线程往往是内核态的，比较重量级，几千个线程可能耗光CPU
4.3MPG模式运行的状态2
1）分成两部分来看
2）原来的情况是M0主线程正在执行G0线程，另外有三个线程在队列等待
3）如果G0线程阻塞，比如读取文件或者数据库等
4）这时就会创建出m1主线程（也可能是从已经有的线程中取出M1）并且将等待的3个协程挂到M1下开始执行，M0的主线程下的G0仍然执行io的读写
5）这样的MPG调度模式，可以既让G0执行同时也可以让队列的其他的协程执行，仍然可以并发执行
6）等到G0不阻塞了，M0会被放到空闲的主线程继续执行（从已有的线程池中获取），同时G0又会被唤醒
5，设置Golang运行的CPU数
说明：为了充分利用多cpu的优势，在Goalng程序中，设置cpu数目
6，channel（管道）-需求
需求：现在要计算1-200各个数的阶乘，并且把各个数的阶乘放到map中。最后显示出来，要求使用goroutine来完成
思路：
1）使用goroutine来完成，效率高，但是会出现并发/并行安全问题
2）这里就提出了不同goroutine如何通信的问题
代码实现：
1）使用goroutine来完成（看看goroutine并发完成会出现什么问题）
2）在运行某个程序时，如何知道是否存在资源竞争问题。在编译程序时，增加一个参数-race即可
package Goroutine
import (
"fmt"
"time"
)
var(
myMap=make(map[int]int,10)
)
//计算n！并放入到map里
func operation(n int) {
res:=1
for i:=1;i<=n;i++{
res*=i
}
myMap[n]=res
}
func Test3() {
//我们开启多个协程去完成这个任务
for i:=1;i<=200;i++{
go operation(i)
}
time.Sleep(time.Second*10)
fmt.Println(myMap)
}
会有错误产生
6.1不同goroutine之间如何通讯
1）全局变量互斥锁
2）使用channel来解决
6.2使用全局变量加锁同步改进程序
因为没有对全局变量加锁，因此会出现资源争夺的问题，代码会出现错误，提示
解决方案：加入互斥锁
我们的数阶乘很大，将数改为uint64（)
package Goroutine
import (
"fmt"
"sync"
"time"
)
var(
myMap2=make(map[int]uint64,10)
//声明一个全局互斥锁，lock是一个全局互斥锁，sync是包：synchorized同步
//Mutex:是互斥
lock sync.Mutex
)
func operation2(n int) {
var res uint64=1
for i:=1;i<=n;i++{
res*=uint64(i)
}
//我们将res放入myMap
//加锁
lock.Lock()
myMap2[n]= res
//解锁
lock.Unlock()
}
func Test4() {
for i:=1;i<=200;i++{
go operation2(i)
}
time.Sleep(time.Second*10)
//这里我们输出
//加锁
lock.Lock()
fmt.Println(myMap2)
lock.Unlock()
}
6.3为什么需要channel
1）前面使用全局变量加锁同步来解决goroutine的通讯并不完美
2）主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置10秒，仅仅是估算
3）如果主线程休眠时间长了，会加长等待时间，如果时间短了，可能还有goroutine处于工作状态，这时也会随着主线程的退出而销毁
4）通过全局变量加锁同步来实现通讯，也并不利于多个协程对全局变量进行读写操作
5）下面来讲以下channel
6.4 channel的基本介绍
1）channel本质是一个数据结构+队列
2）数据是先进先出
3）线程安全，多个goroutine访问时，不需要加锁，就是说channel本身就是线程安全的
4）channel有类型的，一个string的channel只能存放string类型的数据
6.5定义/声明管道
var 变量名 chan 数据类型
举例：
var intChan chan int 存放int类型
var mapChan chan map[int]string mapChan存放map[int]string类型
var perChan chan Person...
说明
channel是引用类型
channel必须初始化才能写入数据，即make后才能用
管道是有类型的，intChan只能写入整数int
6.6管道的初始化，写入数据到管道，从管道读取数据，注意事项
package Goroutine
import "fmt"
func Test5() {
//演示一下管道的使用
//1,创建一个可以存放3个int类型的管道
var intChan chan int
intChan=make(chan int,3)
//2，看看intChan是什么
fmt.Printf("值：%V 地址：%p\n",intChan,&intChan)
//3，向管道写入数据
intChan<-10
num:=211
intChan<-num
intChan<-50
//intchan<-99注意不要超过它的容量
//4,看看管道的长度和cap（容量）
fmt.Printf("长度 len=%v cap=%v\n",len(intChan),cap(intChan))
//5，从管道里读取数据
var num2 int
num2=<-intChan
fmt.Println("num2=",num2)
fmt.Printf("长度 len=%v cap=%v\n",len(intChan),cap(intChan))
//6,在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告deadlock
num3:=<-intChan
num4:=<-intChan
num5:=<-intChan
fmt.Println("num3=",num3,"num4=",num4,"num5=",num5)
}
6.7channel使用的注意事项
1）channel只能存放指定的数据类型
2）channel的数据放满后，就不能再放入了
3）如果从channel取出数据后就可以继续放入
4）在没有使用协程的情况下，如果channel数据取完了，再取就会报错
6.8读写channel案例演示
1）创建一个intChan，最多可以放3个int，演示存三个数据到intChan然后再取出这三个int
2）创建一个mapChan，最多可以存放1个map[string]string演示写入和读取
3）创建一个结构体变量cat，创建一个管道，演示catChan的存取
4）创建一个allchan可以存放任意数据类型的变量
7，练习
1)创建一个person结构体[Name，Age，Address]
2)创建10个Person实例，并放入到channel中
3）遍历channel，将各个person实例信息显示在终端
package Goroutine
import "fmt"
type Person struct {
name string
Age int
Address string
}
func Test9() {
var PersonChan chan Person
PersonChan=make(chan Person,10)
for i:=0;i<10;i++{
PersonChan<-Person{"wang",i,"asa"}
}
for len(PersonChan)!=0{
fmt.Println(<-PersonChan)
}
}
8，chaneel的遍历和关闭
8.1channe的关闭
使用内置函数close可以关闭channel，当channel关闭后，就不能再向channel写数据了，但是仍然可以从该channel读取数据
8.2channel的遍历
channel支持for-range的方式进行遍历
1）在遍历时，如果channel没有关闭，则会出现deadlock错误
2）在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后就会退出遍历
8.3channel遍历和关闭的案例演示
8.4应用实例1
请完成goroutine和channel协同工作的案例
1）开启一个writeData协程，向管道intChan中写入五十个数
2）开启一个readDate协程，从管道intChan中读取writeData写入数据
3）注意：WriteData和readData操作的是同一个管道
4）主线程需要等待writeData和readData协程都完成工作才能退出管道
package Goroutine
import (
"fmt"
)
//writeData
func writeData(intChan chan int) {
for i:=1;i<=50;i++{
intChan<-i
fmt.Println("writeData",i)
}
close(intChan)
}
//readData
func readData(intChan chan int,exitChan chan bool) {
for{
v,ok:=<-intChan
if !ok{
break
}
fmt.Println("readData",v)
//time.Sleep(time.Second)
}
exitChan<-true
close(exitChan)
}
func Test12() {
//创建两个管道
intChan:=make(chan int,50)
exitChan:=make(chan bool,1)
go writeData(intChan)
//time.Sleep(time.Second)
go readData(intChan,exitChan)
//time.Sleep(time.Second)
for{
_,ok:=<-exitChan
fmt.Println("sa")
if!ok{
break
}
}
}
8.5应用实例2-阻塞
如果只是向管道写入数据，而没有读取，就会出现阻塞而dead lock，原因是intChan容量是10，而代码writeData会写入50个数据，因此会阻塞在writeData的ch<-i
8.6应用实例3
要求统计1-200000的数字中，哪些是素数？我们这里采用goroutine和channnel来完成，测试数据是80000
分析思路：
传统的方法是一个循环，判断各个数字是不是素数
现在使用并发知识，将统计素数的任务分配给4个goroutine去完成
package Goroutine
import (
"fmt"
"time"
)
//向intChan放入1-8000个数字
func putNum(intChan chan int){
for i:=1;i<=8000;i++{
intChan<-i
}
//关闭intChan
close(intChan)
}
//从intChan中取出数据，并判断是不是素数，如果是就放入到primeChan
func primeNum(intChan chan int,primeChan chan int,exitChan chan bool){
var flag bool
for{
time.Sleep(time.Millisecond*10)
num,ok:=<-intChan
if!ok{//intChan取不到
break
}
flag=true
for i:=2;i<num;i++{
if num%i==0{
flag=false
break
}
}
if flag{
//就将这个数放入到primeChan
primeChan<-num
}
}
fmt.Println("有一个primeNUM因为取不到数据，退出")
//向exitChan写入true
exitChan<-true
}
func Test13() {
intChan:=make(chan int,1000)
primeChan:=make(chan int,2000)//放入结果
//标识退出管道
exitChan:=make(chan bool,4)
go putNum(intChan)
//开启四个协程
for i:=0;i<4;i++{
go primeNum(intChan,primeChan,exitChan)
}
//这里我们主线程进行处理
//直接
go func() {
for i:=0;i<4;i++{
fmt.Println("exitchan",<-exitChan)
}
//当我们从exitChan中取出来四个结果后，就可以放心的关闭prprimeChan
close(primeChan)
}()
//遍历我们的primeChan
for{
res,ok:=<-primeChan
if !ok{
break
}
fmt.Println("素数",res)
}
fmt.Println("main线程退出")
}
9，channel使用细节和注意事项
1）channel可以声明为只读，或者只写性质
2）channel只读和只写的最佳实践案例
3）使用select可以解决从管道读取数据的阻塞问题
package Goroutine
import (
"fmt"
"time"
)
func Test15() {
//1，定义一个管道存10个数据
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<-"sww"+fmt.Sprintf("%d",i)
}
//在传统的方法中我们不关闭会阻塞而导致deadlock
//我们可以使用select方式解决
for {
select{
//注意，这里如果intchan一直没有关闭，不会一直阻塞而deadlock，会自动到下一个case匹配
case v:=<-intChan:
fmt.Println("数据",v)
time.Sleep(time.Second)
case v:=<-stringChan:
fmt.Println("字符串",v)
time.Sleep(time.Second)
default:
fmt.Println("都取不到了")
return
}
}
}
4）goroutine中使用recover解决协程中出现的panic，导致程序出现问题，这时我们可以在goroutine中使用recover来捕获panic进行处理，这样即使这个协程发生问题，但是主线程仍然不受影响，可以继续执行
package Goroutine
import (
"fmt"
"time"
)
func sayHello() {
for i:=0;i<10;i++{
time.Sleep(time.Second)
fmt.Println("hello world")
}
}
//函数
func errorrecover(){
//这里我们可以使用defer+recover
defer func() {
//捕获test抛出的panic
err:=recover()
if err!=nil{
fmt.Println("test()发生错误",err)
}
}()
var m1 map[int]string
m1[0]="ss"
}
func Test16() {
go sayHello()
go errorrecover()
for i:=0;i<10;i++{
fmt.Println(i)
time.Sleep(time.Second)
}
}
码字不易，还望点个赞，点个关注多多支持一下！谢谢！
（免费订阅,永久学习）学习地址: Dpdk/网络协议栈/vpp/OvS/DDos/NFV/虚拟化/高性能专家-学习视频教程-腾讯课堂
更多DPDK相关学习资料有需要的可以自行报名学习,免费订阅,永久学习,或点击这里加qun免费
领取,关注我持续更新哦! !
原文链接;https://zhuanlan.zhihu.com/p/419186816
