Go语言笔记----goroutine和channel

Go语言笔记----goroutine和channel

• goroutine基本模型和调度设计策略
• • Go对协程的处理
  • Go对早期调度器的处理
  • • 老的调度器缺点
  • GMP
  • 调度器的设计策略
  • • 复用线程
    • • work stealing机制
      • hand off机制
  • 利用并行
  • 抢占策略
  • 全局G队列
• 创建goroutine
• Channel基本定义和使用
• • channel有缓冲和无缓冲同步问题
  • • 无缓冲的channel
    • 有缓冲的Channel
  • Channel的关闭
  • Channel和Range
  • Channel与select

---

goroutine基本模型和调度设计策略

单进程时代的两个问题:

• 单一执行流程,计算机只能一个任务一个任务的处理
• 进程阻塞带来的cpu浪费时间

• 多线程和多进程解决了阻塞问题，但是又遇到了新的问题

• 进程/线程的数量越多，切换成本就越大

• 多线程随着同步竞争(如: 锁，竞争资源冲突等)，开发设计更加复杂

---

思考:如果我把这个线程一分为二会怎么样？

cpu只能看见内核线程

---

• 一个cpu绑定的内核线程可以通过协成调度器轮询处理多个协程
• 但是这样做有一个弊端: 如果轮询过程中在某个协程处阻塞住了，那么后面的协程执行必定受到影响

---

---

---

Go对协程的处理

---

Go对早期调度器的处理

老的调度器缺点

---

GMP

---

调度器的设计策略 复用线程 work stealing机制

---

hand off机制

如果M1对应处理器正在处理的G1阻塞住了，那么你猜猜P的本地队列里面的G2是等待直到阻塞结束呢？还是有什么好的办法可以让他不受阻塞影响，可以接着处理呢？

这里当然是后者了

---

利用并行

GOMAXPROCS可以决定使用多少个CPU

---

抢占策略

相当于利用了时间片机制,每个goroutine最多被cpu宠幸10ms

---

全局G队列

当然会先去其他队列偷，如果其他队列没有，那么才会尝试去全局队列获取，因为去全局队列拿的话，需要加锁和解锁，比较浪费时间

---

创建goroutine

package main

import (
	"fmt"
	"time"
)

//子goroutine
func newTask(){
	i:=0
	for{
		i++
		fmt.Printf("new GoRoutine: i=%dn",i)
		time.Sleep(1*time.Second)
	}
}

func main() {
	//创建一个go程去执行newTask()方法
	go newTask();

	i:=0
	for{
		i++
		fmt.Printf("Main GoRoutine: i=%dn",i)
		time.Sleep(1*time.Second)
	}
}

---

---

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
    //用go创建一个形参为空格,返回值为空的一个函数
    go func(){
    	defer fmt.Println("A.defer")

    	func(){
    		defer fmt.Println("B.defer")
    		//退出当前goroutine
    		runtime.Goexit()//终止当前的goroutine
    		fmt.Println("B")
		}()

    	fmt.Println("A")
	}()//()表示匿名函数的调用

   //这里go和主线程并行执行,如果学过java线程的小伙伴都懂,如果要在两个线程之间传递数据一般需要使用一个通道或者队列来存放共享数据
	go func(a int,b int)bool{
		fmt.Println("a= ",a," b= ",b)
		return true
	}(10,20)

	//如果不等一下的话,主线程直接就结束了,goroutine还没来得及执行就死了
   time.Sleep(time.Second*3)
}

---

Channel基本定义和使用

package main

import (
	"fmt"
	"time"
)

func main() {
	//定义一个channel
	c:=make(chan int)

	go func(){

		defer fmt.Println("goroutine over!!!")

		fmt.Println("goroutine is running!!!")

		fmt.Println("sleeping 2 s")
		time.Sleep(2*time.Second)
		c <-666 //将666发送给c
		time.Sleep(2*time.Second)
		fmt.Println("repeat sleeping 2s")
	}()

	num:= <-c //从c中接收参数,并赋值给num

	fmt.Println("num= ",num)
	fmt.Println("main goroutine over!!!")
}

显然channel的作用就是用来同步的，那么同步机制是什么呢?

还有一种情况:

---

channel有缓冲和无缓冲同步问题 无缓冲的channel

• 在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执⾏发送或者接收。
• 在第 2 步，左侧的 goroutine 将它的⼿伸进了通道，这模拟了向通道发送数据的⾏为。这时，这个 goroutine 会在通道中被锁住，直到交换完成。
• 在第 3 步，右侧的 goroutine 将它的⼿放⼊通道，这模拟了从通道⾥接收数据。这个 goroutine ⼀样也会在通道中被锁住，直到交换完成.
• 在第 4 步和第 5 步，进⾏交换，并最终，在第 6 步，两个 goroutine 都将它们的⼿从通道⾥拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做其他事情了

---

有缓冲的Channel

• 在第 1 步，右侧的 goroutine 正在从通道接收⼀个值
• 在第 2 步，右侧的这个 goroutine独⽴完成了接收值的动作，⽽左侧的 goroutine 正在发送⼀个新值到通道⾥
• 在第 3 步，左侧的goroutine 还在向通道发送新值，⽽右侧的 goroutine 正在从通道接收另外⼀个值。这个步骤⾥的两个操作既不是同步的，也不会互相阻塞
• 最后，在第 4 步，所有的发送和接收都完成，⽽通道⾥还有⼏个值，也有⼀些空间可以存更多的值

特点

• 当channel已经满，再向⾥⾯写数据，就会阻塞
• 当channel为空，从⾥⾯取数据也会阻塞

---

有缓冲Channel使用演示:

package main

import (
	"fmt"
	"time"
)

func main() {
	//定义一个带有缓冲的Channel
	c:=make(chan int,3)

	go func(){

		defer fmt.Println("goroutine over!!!")

		fmt.Println("goroutine is running!!!")

		for i:=0;i<3 ;i++  {
			c<-i
			fmt.Println("发送的元素i= ",i," 通道长度len= ",len(c)," 通道容量cap= ",cap(c))
		}
	}()

	time.Sleep(time.Second)
	for i:=0;i<3 ;i++  {
		num:=<-c
		fmt.Println("num= ",num)
	}

	fmt.Println("main goroutine over!!!")
}

---

错误示范:

func main() {
	//定义一个带有缓冲的Channel
	c:=make(chan int,4)

	go func(){

		defer fmt.Println("goroutine over!!!")

		fmt.Println("goroutine is running!!!")

		for i:=0;i<5 ;i++  {
			c<-i
			fmt.Println("发送的元素i= ",i," 通道长度len= ",len(c)," 通道容量cap= ",cap(c))
		}
	}()

	time.Sleep(time.Second)
	//尝试从channel中读取第六个元素的时候会报错---因为此时没有goroutine会尝试往通道中写入数据
	for i:=0;i<6;i++  {
		num:=<-c
		fmt.Println("num= ",num)
	}

	fmt.Println("main goroutine over!!!")
}

---

Channel的关闭

package main

import (
	"fmt"
)

func main() {
	//定义一个带有缓冲的Channel
	c:=make(chan int)

	go func(){
		for i:=0;i<6;i++  {
			c<-i
		}
		//close可以关闭一个channel
		close(c)
	}()

    for{
    	//ok如果为true表示channel没有关闭,如果为false表示channel已经关闭
    	if data,ok :=<-c; ok{
    		fmt.Println(data)
		}else {
			break
		}
	}

	fmt.Println("main goroutine over!!!")
}

• channel不像⽂件⼀样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的，才去关闭channel
• 关闭channel后，⽆法向channel 再发送数据(引发 panic 错误后导致接收⽴即返回零值)
• 关闭channel后，可以继续从channel接收数据
• 对于nil channel，⽆论收发都会被阻塞

---

Channel和Range

package main

import (
	"fmt"
)

func main() {
	//定义一个带有缓冲的Channel
	c:=make(chan int)

	go func(){
		for i:=0;i<6;i++  {
			c<-i
		}
		//close可以关闭一个channel
		close(c)
	}()


//可以使用range来迭代不断操作channel
//如果channel有数据就循环读取一次,直到通道关闭,才会结束读取
for data:= range c{
	fmt.Println(data)
}

	fmt.Println("main goroutine over!!!")
}

---

Channel与select

单流程下⼀个go只能监控⼀个channel的状态，select可以完成监控多个channel的状态

伪代码:

以斐波那契数列为例吧:

package main

import "fmt"

func main() {
  //无缓冲罐channel	
  c:=make(chan int)
  quit:=make(chan int)

  //sub go
  go func(){
      
	  for i:=0;i<10;i++  {
	  	//输出通道c里面的数据
		//如果通道此时没有数据会阻塞等待
		  fmt.Println(<-c)
	  }
      
	  quit<-0
  }()

  //main go
  fibonacii(c,quit)
}

func fibonacii(c , quit chan int) {
	x,y:=1,1

	for{
	   select{
	   //如果向通道c写入数据x成功,那么会进入下面这个分支语句
	   case c<-x:
	   	 x=y
	   	 y=x+y
	   	 //如果quit通道成功读取到了数据,则进入该分支语句
	   case <-quit:
	   	fmt.Println("quit")
	   	return
	   }
	}
}

select具备多路channel的监控状态功能

---