【学习笔记】go协程和通道

摘自《go语言从入门到进阶实战》和韩顺平《go语言核心编程》

虽然，线程池为逻辑编写者提供了线程分配的抽象机制。但是，如果面对随时随地可能发生的并发和线程处理需求，线程池就不是非常直观和方便了。能否有一种机制：使用者分配足够多的任务，系统能自动帮助使用者把任务分配到CPU上，让这些任务尽量并发运作。这种机制在Go语言中被称为goroutine。goroutine的概念类似于线程，但goroutine由Go程序运行时的调度和管理。Go程序会智能地将goroutine中的任务合理地分配给每个CPU。 Go程序从main包的main()函数开始，在程序启动时，Go程序就会为main()函数创建一个默认的goroutine。

Go 主线程(有程序员直接称为线程/也可以理解成进程): 一个Go 线程上，可以起多个协程，你可以这样理解，协程是轻量级的线程[编译器做优化]。

Go 协程的特点

1. 有独立的栈空间
2. 共享程序堆空间
3. 调度由用户控制
4. 协程是轻量级的线程

Go程序中使用go关键字为一个函数创建一个goroutine。一个函数可以被创建多个goroutine，一个goroutine必定对应一个函数。

使用普通函数创建goroutine

为一个普通函数创建goroutine的写法如下：
go 函数名( 参数列表 )

使用go关键字创建goroutine时，被调用函数的返回值会被忽略。
例子 使用go关键字，将running()函数并发执行，每隔一秒打印一次计数器，而main的goroutine则等待用户输入，两个行为可以同时进行。请参考下面代码：
例一

        package main
        
        import (
                "fmt"
                "time"
        )
        
        func running() {
                
                var times int
                // 构建一个无限循环
                for {
                        times++
                        fmt.Println("tick", times)
        
                        // 延时1秒
                        time.Sleep(time.Second)
                }
        
        }
        
        func main() {
        
                // 并发执行程序
               go running()    
                // 接受命令行输入，不做任何事情
                var input string
                fmt.Scanln(&input)
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

这个例子中，Go程序在启动时，运行时（runtime）会默认为main()函数创建一个goroutine。在main()函数的goroutine中执行到go running语句时，归属于running()函数的goroutine被创建，running()函数开始在自己的goroutine中执行。此时，main()继续执行，两个goroutine通过Go程序的调度机制同时运作。

例二：

结果：
输出的效果说明， main 这个主线程和test 协程同时执行.

主线程和协程执行流程：

总结：

1. 主线程是一个物理线程，直接作用在cpu 上的。是重量级的，非常耗费cpu 资源。
2. 协程从主线程开启的，是轻量级的线程，是逻辑态。对资源消耗相对小。
3. Golang 的协程机制是重要的特点，可以轻松的开启上万个协程。其它编程语言的并发机制是一般基于线程的，开启过多的线程，资源耗费大，这里就突显Golang 在并发上的优势了

设置运行的cpu的数目：

使用匿名函数创建goroutine

1.使用匿名函数创建goroutine的格式
使用匿名函数或闭包创建goroutine时，除了将函数定义部分写在go的后面之外，还需要加上匿名函数的调用参数，格式如下：
go func( 参数列表 ){
函数体
}( 调用参数列表 )
·参数列表：函数体内的参数变量列表。
·函数体：匿名函数的代码。
·调用参数列表：启动goroutine时，需要向匿名函数传递的调用参数。
2.使用匿名函数创建goroutine的例子
在main()函数中创建一个匿名函数并为匿名函数启动goroutine。匿名函数没有参数。代码将并行执行定时打印计数的效果。参见下面的代码：

  01        package main
02        
03        import (
04                "fmt"
05                "time"
06        )
07        
08        func main() {
09        
10                go func() {
11        
12                        var times int
13        
14                        for {
15     times++
16      fmt.Println("tick", times)
17        
18         time.Sleep(time.Second)
19                        }
20        
21                }()
22        
23                var input string
24                fmt.Scanln(&input)
25        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

goroutine虽然类似于线程概念，但是从调度性能上没有线程细致，而细致程度取决于Go程序的goroutine调度器的实现和运行环境。 终止goroutine的最好方法就是自然返回goroutine对应的函数。虽然可以用golang.org/x/net/context包进行goroutine生命期深度控制，但这种方法仍然处于内部试验阶段，并不是官方推荐的特性。

Go语言的协作程序（goroutine）和普通的协作程序（coroutine）

C#、Lua、Python语言都支持coroutine特性。coroutine与goroutine在名字上类似，都可以将函数或者语句在独立的环境中运行，但是它们之间有两点不同：
·goroutine可能发生并行执行；但coroutine始终顺序执行。 狭义地说，goroutine可能发生在多线程环境下，goroutine无法控制自己获取高优先度支持；coroutine始终发生在单线程，coroutine程序需要主动交出控制权，宿主才能获得控制权并将控制权交给其他coroutine。

·goroutine间使用channel通信；coroutine使用yield和resume操作。
goroutine和coroutine的概念和运行机制都是脱胎于早期的操作系统。 coroutine的运行机制属于协作式任务处理，早期的操作系统要求每一个应用必须遵守操作系统的任务处理规则，应用程序在不需要使用CPU时，会主动交出CPU使用权。如果开发者无意间或者故意让应用程序长时间占用CPU，操作系统也无能为力，表现出来的效果就是计算机很容易失去响应或者死机。 goroutine属于抢占式任务处理，已经和现有的多线程和多进程任务处理非常类似。应用程序对CPU的控制最终还需要由操作系统来管理，操作系统如果发现一个应用程序长时间大量地占用CPU，那么用户有权终止这个任务。

通道

单纯地将函数并发执行是没有意义的。函数与函数间需要交换数据才能体现并发执行函数的意义。虽然可以使用共享内存进行数据交换，但是共享内存在不同的goroutine中容易发生竞态问题。为了保证数据交换的正确性，必须使用互斥量对内存进行加锁，这种做法势必造成性能问题。 Go语言提倡使用通信的方法代替共享内存，这里通信的方法就是使用通道（channel）

Go语言中的通道（channel）是一种特殊的类型。在任何时候，同时只能有一个goroutine访问通道进行发送和获取数据。goroutine间通过通道就可以通信。通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。

声明通道类型

通道本身需要一个类型进行修饰，就像切片类型需要标识元素类型。通道的元素类型就是在其内部传输的数据类型，声明如下：

var 通道变量 chan 通道类型
1

·通道类型：通道内的数据类型。
·通道变量：保存通道的变量。 chan类型的空值是nil，声明后需要配合make后才能使用。
创建通道
通道是引用类型，需要使用make进行创建，格式如下：
通道实例 := make(chan 数据类型)

ch1 := make(chan int)  // 创建一个整型类型的通道
ch2 := make(chan interface{}) // 创建一个空接口类型的通道，可以存放任意格式

type Equip struct{ /* 一些字段 */ }
ch2 := make(chan *Equip)  // 创建Equip指针类型的通道，可以存放*Equip
//1. 创建一个可以存放3 个int 类型的管道
var intChan chan int
intChan = make(chan int, 3)
1
2
3
4
5
6
7
8

通道的发送使用特殊的操作符“<-”，将数据通过通道发送的格式为：
通道变量 <- 值
·通道变量：通过make创建好的通道实例。
·值：可以是变量、常量、表达式或者函数返回值等。值的类型必须与ch通道的元素类型一致。

通过通道发送数据的例子

使用make创建一个通道后，就可以使用“<-”向通道发送数据，代码如下：

// 创建一个空接口通道
ch := make(chan interface{})
// 将0放入通道中
ch <- 0
// 将hello字符串放入通道中
ch <- "hello"
1
2
3
4
5
6

发送将持续阻塞直到数据被接收

把数据往通道中发送时，如果接收方一直都没有接收，那么发送操作将持续阻塞。Go程序运行时能智能地发现一些永远无法发送成功的语句并做出提示，代码如下：

func main() {
        // 创建一个整型通道
        ch := make(chan int)

    // 尝试将0通过通道发送
        ch <- 0
}
1
2
3
4
5
6
7

运行代码，报错： fatal error: all goroutines are asleep - deadlock!
报错的意思是：运行时发现所有的goroutine（包括main）都处于等待goroutine。也就是说所有goroutine中的channel并没有形成发送和接收对应的代码。

使用通道接收数据

通道接收同样使用“<-”操作符，通道接收有如下特性：
·通道的收发操作在不同的两个goroutine间进行。 由于通道的数据在没有接收方处理时，数据发送方会持续阻塞，因此通道的接收必定在另外一个goroutine中进行。
·接收将持续阻塞直到发送方发送数据。 如果接收方接收时，通道中没有发送方发送数据，接收方也会发生阻塞，直到发送方发送数据为止。
·每次接收一个元素。 通道一次只能接收一个数据元素。 通道的数据接收一共有以下4种写法。
1.阻塞接收数据 阻塞模式接收数据时，将接收变量作为“<-”操作符的左值，格式如下：
data := <-ch
执行该语句时将会阻塞，直到接收到数据并赋值给data变量。
2.非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
·data：表示接收到的数据。未接收到数据时，data为通道类型的零值。
·ok：表示是否接收到数据。 非阻塞的通道接收方法可能造成高的CPU占用，因此使用非常少。如果需要实现接收超时检测，可以配合select和计时器channel进行，可以参见后面的内容。
3.接收任意数据，忽略接收的数据

阻塞接收数据后，忽略从通道返回的数据，格式如下：
<-ch
执行该语句时将会发生阻塞，直到接收到数据，但接收到的数据会被忽略。这个方式实际上只是通过通道在goroutine间阻塞收发实现并发同步。

01        package main
02        
03        import (
04                "fmt"
05        )
06        
07        func main() {
08        
09                // 构建一个通道
10                ch := make(chan int)
11        
12                // 开启一个并发匿名函数
13                go func() {
14        
15                        fmt.Println("start goroutine")
16        
17                        // 通过通道通知main的goroutine
18                        ch <- 0
19        
20                        fmt.Println("exit goroutine")
21        
22                }()
23        
24                fmt.Println("wait goroutine")
25        
26                // 等待匿名goroutine
27                <-ch
28        
29                fmt.Println("all done")
30        
31        }


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

代码说明如下：
·第10行，构建一个同步用的通道。
·第13行，开启一个匿名函数的并发。
·第18行，匿名goroutine即将结束时，通过通道通知main的goroutine，这一句会一直阻塞直到main的goroutine接收为止。
·第27行，开启goroutine后，马上通过通道等待匿名goroutine结束。 执行代码，输出如下：
wait goroutine
start goroutine
exit goroutine
all done
4.循环接收
通道的数据接收可以借用for range语句进行多个元素的接收操作，格式如下：
for data := range ch {

}
通道ch是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过for遍历获得的变量只有一个，即上面例子中的data。

代码：

import (
	"fmt"
	"time"
)
func main() {
	// 构建一个通道
	ch := make(chan int)
	// 开启一个并发匿名函数
	go func() {
		// 从3循环到0
		for i := 3; i >= 0; i-- {
			// 发送3到0的数值
			ch <- i
			// 每次发送完时等待
			time.Sleep(time.Second)
		}
	}()
	// 遍历接收通道数据
	for data := range ch {
		// 打印通道数据
		fmt.Println(data)
		// 当遇到数据0时，退出接收循环
		if data == 0 {
			break
		}
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

channel 使用的注意事项

1. channel 中只能存放指定的数据类型
2. channle 的数据放满后，就不能再放入了
3. 如果从channel 取出数据后，可以继续放入
4. 在没有使用协程的情况下，如果channel 数据取完了，再取，就会报dead lock