Golang(6)-协程和通道

---

更多关于Golang核心编程知识的文章请看：Golang核心编程(0)-目录页

---

优雅的并发编程范式，完善的并发支持，出色的并发性能是Go语言区别于其他语言的一大特色。

执行体是个抽象的概念，在操作系统层面有多个概念与之对应，比如操作系统自己掌管的进程（process）、进程内的线程（thread）以及进程内的协程（coroutine，也叫轻量级线程）。与传统的系统级线程和进程相比，协程的最大优势在于其“轻量级”，可以轻松创建上百万个而不会导致系统资源衰竭，而线程和进程通常最多也不能超过1万个。这也是协程也叫轻量级线程的原因。

一、协程

Go 语言在语言级别支持轻量级线程，叫goroutine。Go 语言标准库提供的所有系统调用操作（当然也包括所有同步 IO 操作），都会出让 CPU 给其他goroutine。这让事情变得非常简单，让轻量级线程的切换管理不依赖于系统的线程和进程，也不依赖于CPU的核心数量。

1.1、goroutine简单使用

goroutine是Go语言中的轻量级线程实现，由Go运行时（runtime）管理。你将会发现，它的使用出人意料得简单。

假设我们需要实现一个函数Add()，它把两个参数相加，并将结果打印到屏幕上，具体代码如下：

func Add(x, y int) {
	z := x + y
	fmt.Println(z)
}

那么，如何让这个函数并发执行呢?具体代码如下：

	go Add(1, 1)

go 是Go语言中最重要的关键字，这一点从Go语言本身的命名即可看出。
在一个函数调用前加上 go 关键字，这次调用就会在一个新的goroutine中并发执行。当被调用的函数返回时，这个goroutine也自动结束了

二、并发通信

现有如下的例子，add.go:

package main
import "fmt"
func Add(x, y int) {
	z := x + y
	fmt.Println(z)
}
func main() {
	for i := 0; i < 10; i++ {
	go Add(i, i)
}
}

执行是结果是什么呢？屏幕上什么都没有，程序没有正常工作。

是什么原因呢？明明调用了10次 Add() ，应该有10次屏幕输出才对。要解释这个现象，就涉及Go语言的程序执行机制了。

Go程序从初始化 main package 并执行main()函数开始，当 main() 函数返回时，程序退出，且程序并不等待其他goroutine（非主goroutine）结束。

对于上面的例子，主函数启动了10个goroutine，然后返回，这时程序就退出了，而被启动的执行 Add(i, i) 的goroutine没有来得及执行，所以程序没有任何输出。

在循环外加上一条代码，令main()函数先等待，就可以看到打印的结果：
time.Sleep(1000)

2.1、传统并发通信方式

在工程上，有两种最常见的并发通信模型：共享数据和消息。
共享数据是指多个并发单元分别保持对同一个数据的引用，实现对该数据的共享。被共享的数据可能有多种形式，比如内存数据块、磁盘文件、网络数据等。在实际工程应用中最常见的无疑是内存了，也就是常说的共享内存。

2.2、Go的并发通信方式

Go语言提供的是另一种通信模型，即以消息机制而非共享内存作为通信方式：

消息机制认为每个并发单元是自包含的、独立的个体，并且都有自己的变量，但在不同并发单元间这些变量不共享。每个并发单元的输入和输出只有一种，那就是消息。这有点类似于进程的概念，每个进程不会被其他进程打扰，它只做好自己的工作就可以了。不同进程间靠消息来通信，它们不会共享内存。

Go语言提供的消息通信机制被称为channel。

所以，在Go语言中有一句口号：

不要通过共享内存来通信，而应该通过通信来共享内存。

三、channel

channel是Go语言在语言级别提供的goroutine间的通信方式。我们可以使用channel在两个或多个goroutine之间传递消息。channel是进程内的通信方式，因此通过channel传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。

channel是类型相关的。也就是说，一个channel只能传递一种类型的值，这个类型需要在声明channel时指定。

一个例子说明channel：

package main
import "fmt"
func Count(ch chan int) {
	ch <- 1
	fmt.Println("Counting")
}
func main() {
	chs := make([]chan int， 10)
	for i := 0; i < 10; i++ {
		chs[i] = make(chan int)
		go Count(chs[i])
	}
	for _, ch := range(chs) {
		<-ch
	}
}

在这个例子中，我们定义了一个包含10个channel的数组（名为 chs ），并把数组中的每个channel分配给10个不同的goroutine。在每个goroutine的 Add() 函数完成后，我们通过 ch <- 1 语句向对应的channel中写入一个数据。在这个channel被读取前，这个操作是阻塞的。在所有的goroutine启动完成后，我们通过 <-ch 语句从10个channel中依次读取数据。在对应的channel写入数据前，这个操作也是阻塞的。这样，我们就用channel实现了类似锁的功能，进而保证了所有goroutine完成后主函数才返回。

3.1、基本语法

一般channel的声明形式为：

var chanName chan ElementType

与一般的变量声明不同的地方仅仅是在类型之前加了chan关键字。 ElementType 指定这个channel所能传递的元素类型。举个例子，我们声明一个传递类型为 int channel：

var ch chan int

或者，我们声明一个 map ，元素是 bool 型的channel:

var m map[string] chan bool

定义一个channel也很简单，直接使用内置的函数 make() 即可：

ch := make(chan int)

在channel的用法中，最常见的包括写入和读出。将一个数据写入（发送）至channel的语法很直观，如下：

ch <- value

向channel写入数据通常会导致程序阻塞，直到有其他goroutine从这个channel中读取数据。从channel中读取数据的语法是

value := <-ch

如果channel之前没有写入数据，那么从channel中读取数据也会导致程序阻塞，直到channel中被写入数据为止。我们之后还会提到如何控制channel只接受写或者只允许读取，即单向channel。

3.2、select

早在Unix时代， select 机制就已经被引入。通过调用 select() 函数来监控一系列的文件句柄，一旦其中一个文件句柄发生了IO动作，该 select() 调用就会被返回。后来该机制也被用于实现高并发的Socket服务器程序。Go语言直接在语言级别支持 select 关键字，用于处理异步IO问题。

select 的用法与 switch 语言非常类似，由 select 开始一个新的选择块，每个选择条件由
case 语句来描述。与 switch 语句可以选择任何可使用相等比较的条件相比， select 有比较多的限制，其中最大的一条限制就是每个 case 语句里必须是一个IO操作，大致的结构如下：

select {
	case <-chan1:
	// 如果chan1成功读到数据，则进行该case处理语句
	case chan2 <- 1:
	// 如果成功向chan2写入数据，则进行该case处理语句
	default:
	// 如果上面都没有成功，则进入default处理流程
}

可以看出， select 不像 switch ，后面并不带判断条件，而是直接去查看 case 语句。每个case 语句都必须是一个面向channel的操作。比如上面的例子中，第一个 case 试图从 chan1 读取一个数据并直接忽略读到的数据，而第二个 case 则是试图向 chan2 中写入一个整型数1，如果这两者都没有成功，则到达 default 语句。

3.3、缓冲机制

之前我们示范创建的都是不带缓冲的channel，这种做法对于传递单个数据的场景可以接受，但对于需要持续传输大量数据的场景就有些不合适了。接下来我们介绍如何给channel带上缓冲，从而达到消息队列的效果。

c := make(chan int, 1024)

在调用 make() 时将缓冲区大小作为第二个参数传入即可，比如上面这个例子就创建了一个大小为1024的 int 类型 channel ，即使没有读取方，写入方也可以一直往channel里写入，在缓冲区被填完之前都不会阻塞。

3.4、超时机制

在之前对channel的介绍中，我们完全没有提到错误处理的问题，而这个问题显然是不能被忽略的。在并发编程的通信过程中，最需要处理的就是超时问题，即向channel写数据时发现channel已满，或者从channel试图读取数据时发现channel为空。如果不正确处理这些情况，很可能会导致整个goroutine锁死。

Go语言没有提供直接的超时处理机制，但我们可以利用 select 机制。虽然 select 机制不是专为超时而设计的，却能很方便地解决超时问题。因为 select 的特点是只要其中一个 case 已经完成，程序就会继续往下执行，而不会考虑其他 case 的情况。

// 首先，我们实现并执行一个匿名的超时等待函数
timeout := make(chan bool, 1)
go func() {
	time.Sleep(1e9) // 等待1秒钟
	timeout <- true
}()
// 然后我们把timeout这个channel利用起来
select {
	case <-ch:
	// 从ch中读取到数据
	case <-timeout:
	// 一直没有从ch中读取到数据，但从timeout中读取到了数据
}

这样使用 select 机制可以避免永久等待的问题，因为程序会在 timeout 中获取到一个数据后继续执行，无论对 ch 的读取是否还处于等待状态，从而达成1秒超时的效果。

3.5、关闭channel

关闭channel非常简单，直接使用Go语言内置的 close() 函数即可：
close(ch)在介绍了如何关闭channel之后，我们就多了一个问题：如何判断一个channel是否已经被关闭？我们可以在读取的时候使用多重返回值的方式：

x, ok := <-ch

这个用法与 map 中的按键获取 value 的过程比较类似，只需要看第二个 bool 返回值即可，如果返回值是 false 则表示 ch 已经被关闭。

四、同步锁和读写锁

Go语言包中的 sync 包提供了两种锁类型： sync.Mutex 和 sync.RWMutex 。 Mutex 是最简单的一种锁类型，同时也比较暴力，当一个goroutine获得了 Mutex 后，其他goroutine就只能乖乖等到这个goroutine释放该 Mutex 。基于同步锁机制。

RWMutex 相对友好些，是经典的单写多读模型。在读锁占用的情况下，会阻止写，但不阻止读，也就是多个goroutine可同时获取读锁（调用 RLock() 方法；而写锁（调用 Lock() 方法）会阻止任何其他goroutine（无论读和写）进来，整个锁相当于由goroutine独占。基于读写锁机制。

对于这两种锁类型，任何一个 Lock() 或 RLock() 均需要保证对应有 Unlock() 或 RUnlock()调用与之对应，否则可能导致等待该锁的所有goroutine处于饥饿状态，甚至可能导致死锁，这种经典的死锁问题被称为饥饿死锁问题，锁的典型使用模式如下：

var l sync.Mutex
func foo() {
	l.Lock()
	defer l.Unlock()
//...
}