示例剖析golang中的CSP并发模型

1. 相关概念：　

用户态：当一个进程在执行用户自己的代码时处于用户运行态（用户态）

内核态：当一个进程因为系统调用陷入内核代码中执行时处于内核运行态（内核态），引入内核态防止用户态的程序随意的操作内核地址空间，具有一定的安全保护作用。这种保护模式是通过内存页表操作等机制，保证进程间的地址空间不会相互冲突，一个进程的操作不会修改另一个进程地址空间中的数据。

用户态与内核态之间的切换：当在系统中执行一个程序时，大部分时间都是运行在用户态下的，在其需要操作系统帮助完成一些用户态自己没有特权和能力完成的操作时就会切换到内核态。有以下三种方式：

（1）系统调用(中断)用户态进程主动要求切换到内核态的一种方式。

（2）异常cpu运行时如果发生一些没有预知的异常，会触发当前进程切换到处理此异常的内核相关进程中。　

（3）外围设备的中断用户态进程主动要求切换到内核态的一种方式。

协程：又称微线程，纤程。英文名Coroutine。Coroutine是一种运行在用户态的用户线程，类似于 greenthread。协程与线程都相互独立，且有自己的上下文，不同之处在于，协程的切换由其自身控制，而线程的切换收到系统调度。

2. CSP (通信顺序进程)　

CSP模型用来描述两个独立的并发实体通过共享的通讯channel管道进行通信的并发模型。

golang借用了CSP模型的一些概念如：实体 process，通道 channel，为之实现并发进行了理论支持，实际上并没有完全实现CSP模型的所有理论。process是在go语言上的表现就是goroutine，是实际上并发执行的实体，每个实体之间是通过channel通讯来实现数据共享。

3. channel：同步&传递消息

channel是被单独创建并且可以在进程之间传递，它的通信模式类似于boss-worker模式，一个实体通过将消息发送到channel中，然后又监听这个channel的实体处理，两个实体之间是匿名的，实现原理上其实是一个阻塞的消息队列。

具体可以分为：有/无缓存channel，只读channel，只写channel，双向channel

写操作：chan <- value

读操作：<- chan

// Create channel
// Unbuffered channel
umbuffer_chan := make(chan int)
// Buffered channel
// Buffer Size = 3
buffer_chan := make(chan int,3)
// Read-Only channel
read_channel := make(&lt;-chan int)
// Receive-Only channel
receive_channel := make(chan&lt;- int)

生产者-消费者Sample：

package main
import (
   "fmt" 
   "time"
)
// 生产者
func Producer (queue chan&lt;- int){
        for i:= 0; i &lt; 10; i++ {
                queue &lt;- i
        }
}
// 消费者
func Consumer( queue &lt;-chan int){
        for i :=0; i &lt; 10; i++{
                v := &lt;- queue
                fmt.Println("receive:", v)
        }
}
func main(){
        queue := make(chan int, 1)
        go Producer(queue)
        go Consumer(queue)
        time.Sleep(1e9) //让Producer与Consumer完成
}

4. goroutine：实际并发执行的实体

在函数或者方法前面加上关键字go，就创建了并发运行的goroutine，eg:

go func (){
}
func Test(){
}
// ...
go Test()

实例代码:

package main  // 代码包声明语句。
import (
   "fmt" //系统包用来输出的
   "math/rand"
   "runtime"
   "sync"
   "time"
)
func main() {
   // 分配一个逻辑处理器给调度器使用
   runtime.GOMAXPROCS(1)
   // WaitGroup是一个计数信号量，用来记录和维护运行的goroutine，如果当前的wg&gt;0，对应的exit方法就会阻塞
   var wg sync.WaitGroup
   // 计数加2表示要等待两个goroutine
   wg.Add(2)
   fmt.Printf("Start Goroutines \n", )
   // 声明匿名函数，创建goroutine
   go func(){
      // 关键字defer会修改函数调用时机，在函数退出时调用Done来通知main函数工作已经完成
      defer wg.Done()
      for count:=0; count&lt;3; count++ {
         for char :='a'; char&lt;'a'+26 ; char++ {
            fmt.Printf("%c ", char)
         }
      }
   }()
   // 声明匿名函数，创建goroutine
   go func() {
      // 函数退出时调用Done来通知main函数工作已经完成
      defer wg.Done()
      for count:=0; count&lt;3; count++ {
         for char :='A'; char&lt;'A'+26 ; char++ {
            fmt.Printf("%c ", char)
         }
      }
   }()
   fmt.Println("Waiting to finish!\n", )
   // 等待结束
   wg.Wait()
   fmt.Println("\nTerminate program! \n", )
}

5. golang调度器

OS在物理处理器上调度线程来运行，而golang在逻辑处理器上调度goroutine来运行。每个逻辑处理器都分别绑定到单个操作系统线程。

如果创建一个goroutine并准备运行，这个goroutine就会被放到调度器的全局运行队列中。之后，调度器就会将队列中的goroutine分配给一个逻辑处理器，并放到这个逻辑处理器对应的本地运行队列中。本地运行队列中的goroutine会一直等待，知道自己被分配到相应的逻辑处理器上运行。

eg：

其中：

M：Machine，一个M直接关联了一个内核线程。

P：Processor，代表了M所需要的上下文环境，也就是处理用户级代码逻辑的处理器。

G：Goroutine，本质上是一种轻量级的线程--协程。

MPG模型，三者关系的宏观图为：

Processor的作用：

当内核线程阻塞的时候，由于上下文的存在，我们能够直接放开其他线程，继续去执行未阻塞的线程，例子如下：

如果当前，G0由于I/O，系统调用进行了阻塞，这个时候M0就可以放开其他的线程：

M0和G0进行系统调用，等待返回值，上下文P以及routine队列交由M1进行执行。当M0执行系统调用结束后，M0会尝试去steal("偷")一个上下文，如果不成功，M0就把它的G0放到一个全局的运行队列中，然后将自己放到线程池或者转入休眠状态。

Global runqueue是各个上下文P在运行完自己的本地的goroutine runqueue后用来拉取新的goroutine的地方（steal working算法）。此外，P也会周期性的检查Global runqueue上的goroutine，来防止全局上的goroutine因为得不到执行而饿死。

频道导航