Python虽然也支持协程模式,但一直被诟病并发很弱，因为GIL的关系，Python在单进程运行的情况下，无法利用多核CPU，所以就被其他能在单进程的情况下利用多核CPU的语言“吊打”性能了，相对而言Python语言是比较慢的。
Java常用的hotspot的JVM，采用的是第一种1:1的线程模型，即：map a java thread to a native thread，也就是说java线程会和native线程有个一一映射的关系，如果看下java的Thread类就可以发现有很多的native方法，这就涉及到操作系统的线程了。java因为采用的是1:1的线程模型，线程数量特别是并发线程数会受到CPU和操作系统的限制。
Go
- Go是一门号称从语言层面支持并发的编程语言，支持并发也是Go非常重要的特性之一
- Go支持协程，协程可以类比Java中的线程，解决并发问题的难点在于线程（协程）之间的协作
- Go提供了两种方案
- 支持协程之间以共享内存的方式通信，Go提供了管程和原子类来对协程进行同步控制，该方案与Java类似
- 支持协程之间以消息传递的方式通信，本质上是要避免共享，该方案是基于CSP模型实现的，Go推荐该方案
CSP模型
- CSP：Communicating Sequential Processes
- Do not communicate by sharing memory; instead, share memory by communicating.
累加器
package main
import (
"fmt"
"time"
)
func main() {
singleCoroutine()
multiCoroutine()
}
// 单协程，只能用到CPU的一个核
func singleCoroutine() {
var result, i uint64
start := time.Now()
for i = 1; i <= 10000000000; i++ {
result += i
}
elapsed := time.Since(start)
fmt.Println(elapsed, result) // 4.330357206s 13106511857580896768
}
// 多协程
func multiCoroutine() {
var result uint64
start := time.Now()
ch1 := calc(1, 2500000000)
ch2 := calc(2500000001, 5000000000)
ch3 := calc(5000000001, 7500000000)
ch4 := calc(7500000001, 10000000000)
// 主协程需要与子协程通信，Go中协程之间的通信推荐使用channel
result = <-ch1 + <-ch2 + <-ch3 + <-ch4
// ch1只能读取数据，如果通过ch1写入数据，编译时会报错
// ch1 <- 7 // invalid operation: ch1 <- 7 (send to receive-only type <-chan uint64)
elapsed := time.Since(start)
fmt.Println(elapsed, result) // 1.830920702s 13106511857580896768
}
// 返回一个只能接收数据的channel
// 方法创建的子协程会把计算结果发送到这个channel，而主协程会通过channel把计算结果取出来
func calc(from uint64, to uint64) <-chan uint64 {
// channel用于协程间的通信，这是一个无缓冲的channel
channel := make(chan uint64)
go func() {
result := from
for i := from + 1; i <= to; i++ {
result += i
}
// 将结果写入channel
channel <- result
}()
// 返回用于通信的channel
return channel
}
生产者-消费者模式
- 可以把Go实现的CSP模式类比成生产者-消费者模式，而channel类比成生产者-消费者模式中的阻塞队列
- Go中channel的容量可以为0，容量为0的channel被称为无缓冲的channel，容量大于0的channel被称为有缓冲的channel
- 无缓冲的channel类似于Java中提供的SynchronousQueue，主要用途是在两个协程之间做数据交换
- Go中的channel是语言层面支持的，使用左向箭头<-完成向channel发送数据和读取数据的任务
- Go中的channel是支持双向传输的，即一个协程既可以通过它发送数据，也可以通过它接收数据
- Go中的双向channel可以变成一个单向channel
- calc中创建了一个双向channel，但是返回的是一个只能接收数据的单向channel
- 所以在主协程中，只能通过该channel接收数据，而不能通过它发送数据
// 创建一个容量为4的channel
channel := make(chan int, 4)
// 创建4个协程，作为生产者
for i := 0; i < 4; i++ {
go func() {
channel <- 7
}()
}
// 创建4个协程，作为消费者
for i := 0; i < 4; i++ {
go func() {
o := <-channel
fmt.Println("received : ", o)
}()
}
Actor模式
- Go实现的CSP模式和Actor模式都是通过消息传递的方式来避免共享，主要有以下三个区别
- Actor模型中没有channel，Actor模型中的Mailbox与channel非常类似，看起来都是FIFO队列，但本质区别很大
- Actor模型
- Mailbox对程序员是透明的，Mailbox明确归属于某一个特定的Actor，是Actor模型的内部机制
- Actor之间可以直接通信，不需要通信媒介
- CSP模型
- channel对于程序员来说是可见的
- channel是通信媒介，传递的消息都直接发送到channel中
- Actor模型中发送消息是非阻塞的，而CSP模型中是阻塞的
- Go实现的CSP模型，channel是一个阻塞队列
- 当阻塞队列已满的时候，向channel发送数据，会导致发送消息的协程阻塞
- Actor模型理论上不保证消息百分比送达，而Go实现的CSP模型中，是能保证消息百分百送达的（代价：可能导致死锁）
func main() {
// 无缓冲的channel
channel := make(chan int)
// fatal error: all goroutines are asleep - deadlock!
// 主协程会阻塞在此处，发生死锁
<-channel
}
小结
- CSP模型是Tony Hoare在1978年提出的，该模型一直都在发展，其理论远比Go实现的复杂得多
- Tony Hoare在并发领域还有另一项重要成就，即霍尔管程模型，这是Java解决并发问题的理论基础
- Java可以借助第三方类库JCSP来支持CSP模型，相比Go的实现，JCSP更接近理论模型
- JCSP并没有经过广泛的生产环境检验，因此不推荐在生产环境使用