1. select
-
select 的作用
Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。
elect的用法与switch语言非常类似，由select开始一个新的选择块，每个选择条件由case语句来描述。
与switch语句相比，select有比较多的限制，其中最大的一条限制就是每个case语句里必须是一个IO操作，大致的结构如下：
select {
case <- chan1:
// 如果chan1成功读到数据，则进行该case处理语句
case chan2 <- 1:
// 如果成功向chan2写入数据，则进行该case处理语句
default:
// 如果上面都没有成功，则进入default处理流程
}
在一个select语句中，Go语言会按顺序从头至尾评估每一个发送和接收的语句。
如果其中的任意一语句可以继续执行(即没有被阻塞)，那么就从那些可以执行的语句中任意选择一条来使用。
如果没有任意一条语句可以执行(即所有的通道都被阻塞)，那么有两种可能的情况：
如果给出了default语句，那么就会执行default语句，同时程序的执行会从select语句后的语句中恢复。
如果没有default语句，那么select语句将被阻塞，直到至少有一个通信可以进行下去。
示例代码：
package main
import (
"fmt"
)
func fibonacci(c, quit chan int) {
x, y := 1, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 6; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
运行结果如下：
-
超时
有时候会出现goroutine阻塞的情况，那么我们如何避免整个程序进入阻塞的情况呢？我们可以利用select来设置超时，通过如下的方式实现：
func main() {
c := make(chan int)
out := make(chan bool)
go func() {
for {
select {
case v := <-c:
fmt.Println(v)
case <-time.After(5 * time.Second):
fmt.Println("timeout")
out <- true
return
}
}
}()
//c <- 666
<-out
}
2. 锁
前面我们为了解决协程同步的问题我们使用了channel，但是GO也提供了传统的同步工具。
它们都在GO的标准库代码包sync和sync/atomic中。
下面我们看一下锁的应用。
什么是锁呢？就是某个协程（线程）在访问某个资源时先锁住，防止其它协程的访问，等访问完毕解锁后其他协程再来加锁进行访问。这和我们生活中加锁使用公共资源相似，例如：公共卫生间。
-
死锁
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，
示例代码：
package main
import "fmt"
func main() {
ch := make(chan int)
ch <- 1 // I'm blocked because there is no channel read yet.
fmt.Println("send")
go func() {
<-ch // I will never be called for the main routine is blocked!
fmt.Println("received")
}()
fmt.Println("over")
}
-
互斥锁
每个资源都对应于一个可称为 "互斥锁" 的标记，这个标记用来保证在任意时刻，只能有一个协程（线程）访问该资源。其它的协程只能等待。
互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法，Lock和Unlock。Lock锁定当前的共享资源，Unlock进行解锁。
在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助defer。锁定后，立即使用defer语句保证互斥锁及时解锁。如下所示：
var mutex sync.Mutex // 定义互斥锁变量 mutex
func write() {
mutex.Lock()
defer mutex.Unlock()
}
我们可以使用互斥锁来解决前面提到的多任务编程的问题，如下所示：
package main
import (
"sync"
"fmt"
"time"
)
var mutex sync.Mutex
func printer(str string){
mutex.Lock() // 添加互斥锁
defer mutex.Unlock() // 使用结束时解锁
for _, data := range str { // 迭代器
fmt.Printf("%c", data)
time.Sleep(time.Second) // 放大协程竞争效果
}
fmt.Println()
}
func person1(s1 string){
printer(s1)
}
func person2(){
printer("world") // 调函数时传参
}
func main() {
go person1("hello") // main 中传参
go person2()
for {
;
}
}
程序执行结果与多任务资源竞争时一致。最终由于添加了互斥锁，可以按序先输出hello再输出 world。但这里需要我们自行创建互斥锁，并在适当的位置对锁进行释放。
-
读写锁
互斥锁的本质是当一个goroutine访问的时候，其他goroutine都不能访问。这样在资源同步，避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。
其实，当我们对一个不会变化的数据只做“读”操作的话，是不存在资源竞争的问题的。因为数据是不变的，不管怎么读取，多少goroutine同时读取，都是可以的。
所以问题不是出在“读”上，主要是修改，也就是“写”。修改的数据要同步，这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的。
因此，衍生出另外一种锁，叫做读写锁。
读写锁可以让多个读操作并发，同时读取，但是对于写操作是完全互斥的。也就是说，当一个goroutine进行写操作的时候，其他goroutine既不能进行读操作，也不能进行写操作。
GO中的读写锁由结构体类型sync.RWMutex表示。此类型的方法集合中包含两对方法：
一组是对写操作的锁定和解锁，简称“写锁定”和“写解锁”：
func (*RWMutex)Lock()
func (*RWMutex)Unlock()
另一组表示对读操作的锁定和解锁，简称为“读锁定”与“读解锁”：
func (*RWMutex)RLock()
func (*RWMutex)RUnlock()
读写锁基本示例：
package main
import (
"math/rand"
"time"
"fmt"
"runtime"
"sync"
)
var count = 0
var reMutex sync.RWMutex
func read(index int) {
for {
reMutex.RLock()
num := count
fmt.Println(index, "读出", num)
time.Sleep(time.Millisecond * 300)
reMutex.RUnlock()
}
}
func write(index int) {
for {
// 产生随机数
rand.Seed(time.Now().UnixNano())
data := rand.Intn(500)
reMutex.Lock()
count = data
fmt.Println(index, "写入", data)
time.Sleep(time.Millisecond * 300)
reMutex.Unlock()
}
}
func main() {
for i := 0; i < 5; i++ {
go write(i+1)
}
for i := 0; i < 5; i++ {
go read(i+1)
}
for {
runtime.GC()
}
}
我们在read里使用读锁，也就是RLock和RUnlock，写锁的方法名和我们平时使用的一样，是Lock和Unlock。这样，我们就使用了读写锁，可以并发地读，但是同时只能有一个写，并且写的时候不能进行读操作。
我们从结果可以看出，读取操作可以并行，例如2,3,1正在读取，但是同时只能有一个写，例如1正在写，只能等待1写完，这个过程中不允许进行其它的操作。
处于读锁定状态，那么针对它的写锁定操作将永远不会成功，且相应的Goroutine也会被一直阻塞。因为它们是互斥的。
总结：读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的。但是，多个读操作之间不存在互斥关系。
从互斥锁和读写锁的源码可以看出，它们是同源的。读写锁的内部用互斥锁来实现写锁定操作之间的互斥。可以把读写锁看作是互斥锁的一种扩展。
3. 条件变量
在讲解条件变量之前，先回顾一下前面我们所涉及的“生产者消费者模型”：
package main
import "fmt"
func producer(send chan<- int) {
for i:=0; i<10; i++ {
send <- i * i
//fmt.Println("生产者 产生：", i*i)
}
close(send)
}
func consumer(recv <-chan int) {
for {
if num, ok := <-recv; ok {
fmt.Println("消费者 消费：", num)
} else {
break
}
}
/* // 判断 channel 是否关闭。
for num := range recv {
fmt.Println("消费者 消费：", num)
}*/
}
func main() {
// 创建缓冲区，带缓冲 双向 channel
ch := make(chan int, 5)
go producer(ch) // 子go程 --- 生产者
consumer(ch) // 主 go 程 --- 消费者
}
这个案例中，虽然实现了生产者消费者的功能，但有一个问题。如果有多个消费者来消费数据，并且并不是简单的从channel中取出来进行打印，而是还要进行一些复杂的运算。在consumer( )方法中的实现是否有问题呢？如下所示：
package main
import (
"math/rand"
"time"
"fmt"
"runtime"
)
func producer(out chan<- int, idx int) {
for {
num := rand.Intn(500)
out <- num
fmt.Printf("-----%dth 生产者，生产：%d\n", idx, num)
time.Sleep(time.Millisecond * 500)
}
}
func consumer(in <-chan int, idx int) {
for {
num := <- in
fmt.Printf("%dth 消费者，消费：%d\n", idx, num)
time.Sleep(time.Millisecond * 200)
}
}
func main() {
rand.Seed(time.Now().UnixNano())
ch := make(chan int, 5)
for i := 0; i < 5; i++ {
go producer(ch, i+1)
}
for i := 0; i < 5; i++ {
go consumer(ch, i+1)
}
for {
runtime.GC()
}
}
在上面的代码中，加入了多个消费者和生产者，同时在consumer方法中，将数据取出来后，又进行了一组运算。这时可能会出现一个协程从管道中取出数据，参与加法运算，但是还没有算完另外一个协程又从管道中取出一个数据赋值给了num变量。所以这样累加计算，很有可能出现问题。当然，按照前面的知识，解决这个问题的方法很简单，就是通过加锁的方式来解决。
另外一个问题，如果消费者比生产者多，仓库中就会出现没有数据的情况。我们需要不断的通过循环来判断仓库队列中是否有数据，这样会造成cpu的浪费。反之，如果生产者比较多，仓库很容易满，满了就不能继续添加数据，也需要循环判断仓库满这一事件，同样也会造成CPU的浪费。
我们希望当仓库满时，生产者停止生产，等待消费者消费；同理，如果仓库空了，我们希望消费者停下来等待生产者生产。为了达到这个目的，这里引入条件变量。（需要注意：如果仓库队列用channel，是不存在以上情况的，因为channel被填满后就阻塞了，或者channel中没有数据也会阻塞）。
条件变量：条件变量的作用并不保证在同一时刻仅有一个协程（线程）访问某个共享的数据资源，而是在对应的共享数据的状态发生变化时，通知阻塞在某个条件上的协程（线程）。条件变量不是锁，在并发中不能达到同步的目的，因此条件变量总是与锁一块使用。
例如，我们上面说的，如果仓库队列满了，我们可以使用条件变量让生产者对应的goroutine暂停（阻塞），但是当消费者消费了某个产品后，仓库就不再满了，应该唤醒（发送通知给）阻塞的生产者goroutine继续生产产品。
GO标准库中的sync.Cond类型代表了条件变量。条件变量要与锁（互斥锁，或者读写锁）一起使用。成员变量L代表与条件变量搭配使用的锁。
type Cond struct { noCopy noCopy // L is held while observing or changing the condition L Locker notify notifyList checker copyChecker}
对应的有3个常用方法，Wait，Signal，Broadcast。
-
func (c *Cond) Wait()
该函数的作用可归纳为如下三点：1 ) 阻塞等待条件变量满足
2 ) 释放已掌握的互斥锁相当于cond.L.Unlock()。 注意：两步为一个原子操作。
3 ) 当被唤醒，Wait()函数返回时，解除阻塞并重新获取互斥锁。相当于cond.L.Lock() func (c *Cond) Signal()
单发通知，给一个正等待（阻塞）在该条件变量上的goroutine（线程）发送通知。func (c *Cond) Broadcast()
广播通知，给正在等待（阻塞）在该条件变量上的所有goroutine（线程）发送通知。
下面我们用条件变量来编写一个“生产者消费者模型”:
package main
import (
"sync"
"runtime"
"math/rand"
"time"
"fmt"
)
// 使用channl实现消费者生产者模型。
func producer(out chan<- int, cond *sync.Cond) {
for {
cond.L.Lock()
for len(out) == 5 {
cond.Wait()
}
num := rand.Intn(500)
out <- num
fmt.Println("----生产数据：", num)
time.Sleep(time.Millisecond * 100)
cond.L.Unlock()
cond.Signal()
}
}
func consumer(in <-chan int, cond *sync.Cond) {
for {
cond.L.Lock()
if len(in) == 0 {
cond.Wait()
}
num := <- in
fmt.Println("消费数据：",num)
time.Sleep(time.Millisecond * 200)
cond.L.Unlock()
cond.Signal()
}
}
func main() {
rand.Seed(time.Now().UnixNano())
// 创建带缓冲channel
ch := make(chan int, 5)
cond := new(sync.Cond)
cond.L = new(sync.Mutex)
for i := 0; i < 5; i++ {
go producer(ch, cond)
}
for i := 0; i < 5; i++ {
go consumer(ch, cond)
}
for true {
runtime.GC()
}
}
- 定义ch作为队列，生产者产生数据保存至队列中，最多存储5个数据，消费者从中取出数据模拟消费
- 条件变量要与锁一起使用，这里定义全局条件变量cond，它有一个属性：L Locker。是一个互斥锁。
- 开启5个消费者协程，开启5个生产者协程。
- producer生产者，在该方法中开启互斥锁，保证数据完整性。并且判断队列是否满，如果已满，调用wait()让该goroutine阻塞。当消费者取出数后执行cond.Signal()，会唤醒该goroutine，继续生产数据。
- consumer消费者，同样开启互斥锁，保证数据完整性。判断队列是否为空，如果为空，调用wait()使得当前goroutine阻塞。当生产者产生数据并添加到队列，执行cond.Signal() 唤醒该goroutine。
