golang（8）：channel读写 & goroutine 通信

goroutine 

1、进程和线程

A. 进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位
B. 线程是进程的一个执行实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位
C. 一个进程可以创建和撤消多个线程；同一个进程中的多个线程之间可以并发执行

2. 协程和线程

协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级线程，这些用户线线程的调度也是自己实现的 （go func() 起的就是协程）
线程：一个线程上可以跑多个协程，协程是轻量级的线程 （一个物理线程可以跑多个协程）

3. 不同 goroutine 之间进行通信

// a. 全局变量 和 锁同步
// b. Channel

打印1到10所有数的阶乘（全局变量 和 锁同步）

// 示例代码：
package main 

import (
    "fmt"
    "time"
    "sync"        // 修改公共数据要加锁
)

var (
    m = make(map[int]uint64)        // 定义一个全局变量的切片，用于保存生成的阶乘结果
    lock sync.Mutex                        // 定义一个互斥锁
)

type task struct {
    n int
}

func calc(p *task){
    var sum uint64
    sum = 1

    for i := 1; i <= p.n; i++ {
        sum *= uint64(i)        // i 是 int 类型， sum 是 uint 类型，要强转一下
    }

    lock.Lock()            // 加锁；修改公共数据    要加锁
    m[p.n] = sum
    lock.Unlock()        // 释放锁

}

func main(){
    for i:= 0; i <= 10; i++ {
        t := &task{i}
        fmt.Printf("%d addr:%p\n",i,&t)
        go calc(t)        // 开启 11 个新线程
    }    

    time.Sleep(time.Second * 5)

    lock.Lock()        // 由于读取的公共数据，而且不知道 sleep 5 秒后所有的 goroutine 是否已经全部执行完，所以此时读取 m 也要加锁
    for k,v := range m {
        fmt.Printf("%d! = %v\n",k,v)
    }
    lock.Unlock()


    // 如果想知道你的程序在执行过程中有没有资源竞争的情况，可以在 build 的时候加上 --race 参数
}


// 运行结果：
[root@NEO example01_goroutine01_factorial]# go run main/main.go
0 addr:0xc00000e030            // 每次生成的 t 都是不同的地址
1 addr:0xc00000e040
2 addr:0xc00000e048
3 addr:0xc00000e050
4 addr:0xc00000e058
5 addr:0xc00000e060
6 addr:0xc00000e068
7 addr:0xc00000e070
8 addr:0xc00000e078
9 addr:0xc00000e080
10 addr:0xc00000e088
10! = 3628800
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
0! = 1
1! = 1
2! = 2
8! = 40320
9! = 362880
[root@NEO example01_goroutine01_factorial]# 

// 第一次写上面的代码的时候，犯了如下错误：
func main(){
    var t task        // 错误原因： 全程只生成了这一个 t 
    for i:= 0; i <= 10; i++ {
        t.n = i        // 每次修改 t.n 是都是在对同一个 t 的 n 作修改
        fmt.Printf("%d addr:%p\n",i,&t)
        go calc(&t)        //  calc(&t) 在调用 t.n 时，好多线程用的都是同一个 t 中的 n
    }    
    
    ...
}

 

channel

channel概念：

a. 类似 unix 中的管道（pipe）
b. 先进先出
c. 线程安全，多个 goroutine 同时访问，不需要加锁
d. channel 是有类型的，一个整数的 channel 只能存放整数

管道分类：

1） 无缓存区管道，如下：
ch := make(chan int)        // By default, sends and receives block until the other side is ready. （无缓存区管道中，只有当发送者和接收者都准备好的时候，管道才不会阻塞）

2） 有缓存区管道，如下：
ch := make(chan int, 100)
// Sends to a buffered channel block only when the buffer is full. Receives block when the buffer is empty.  （有缓存区的管道）

 

无缓存区管道示例：

1） 错误示例：
package main

func main(){
    var ch chan int
    ch = make(chan int)        // 无缓存区管道
    
    ch <- 10        // 此时会阻塞，因为无缓存区管道中，只有当接收者和发送者都准备好时，才不会阻塞，但程序永远都到不了接收读数据（下面一行的代码），所以程序会阻塞在这一步，由于又是阻塞在了主线程，main函数无法继续执行以后的代码，所以会 panic
    <- ch        // 从管道中取出一个数据
}

// 运行结果：
[root@NEO ~]# go run main.go
fatal error: all goroutines are asleep - deadlock!        // 直接死锁

goroutine 1 [chan send]:
main.main()
    /root/main.go:16 +0x55
exit status 2
[root@NEO ~]#


2） 正确示例：
package main

import (
    "fmt"
)

func main(){
    var ch chan int
    ch = make(chan int)        // 无缓存区管道
        
    go func(){            // 新开一个 goroutine；
        ch <- 10        // 新开的子线程也会阻塞在这一步；但由于不是阻塞了主线程，程序就不会 panic
    }()
    a :=<- ch                // 从管道中读取数据；当从管道中读取数据时，上面新开的 goroutine 就不会阻塞了
    fmt.Println(a)
}

// 运行结果：
[root@NEO ~]# go run main.go
10
[root@NEO ~]# 

无缓存区管道死锁参考：https://blog.csdn.net/u011328417/article/details/89473323

channel 声明

// var 变量名 chan 类型
var test chan int
var test chan string
var test chan map[string]string
var test chan stu
var test chan *stu

示例代码：

package main

import "fmt"

type student struct{
    name string
}

func main(){
    var mapChan chan map[string]string                // 声明一个 channel；chan + 变量类型 才是管道的类型
    mapChan = make(chan map[string]string,10)        // 管道初始化；管道满了后就不能再往里面写了（也可以阻塞）
    m := make(map[string]string,16)                    // 声明并初始化；超过16个元素后 m 会自动扩容
    m["stu01"] = "neo01"
    m["stu02"] = "neo02"
    mapChan <- m            // 把 m 写入 mapChan 管道

    var stuChan chan *student
    stuChan = make(chan *student,10)    // 初始化的时候也要 chan *student
    stu := student{name:"neo"}
    stuChan <- &stu        // 写入是传入地址

    var interfChan chan interface{}            // interface{} --> 这样 channel 中可存任何类型
    interfChan = make(chan interface{},10)
    interfChan <- stu

    /*
    stu01 :=<- interfChan            // 读取 interfChan；声明并初始化 stu01
    fmt.Printf("stu01:%v\n",stu01)
    */
    var stu01 interface{}        // stu01 是一个接口类型
    stu01 =<- interfChan

    stu02,ok := stu01.(student)            // 断言
    if !ok {
        fmt.Println("can not convert")
        return
    }
    fmt.Println("stu02:",stu02)
    
}


// 运行结果：
[root@NEO example02_channel01]# go run main/main.go
stu02: {neo}
[root@NEO example02_channel01]#

channel 和 goroutine 相结合的事例（一个goroutine写，一个goroutine读）

// 示例代码：
package main

import (
    "fmt"
    "time"
)

func write(ch chan int){    // 管道 chan 后面一定要加上变量类型
    for i := 0; i < 15; i++{
        ch <- i
        fmt.Printf("put data i:%d\n",i)
    }    
}

func read(ch chan int){
    for {
        var b int
        b =<- ch
        fmt.Println(b)
        time.Sleep(time.Second)
    }
}


func main() {
    var intChan chan int
    intChan = make(chan int,10)        // 管道超过10个元素后，就不能再管道中添加元素（再加就也会阻塞）

    go write(intChan)
    go read(intChan)

    time.Sleep(time.Second * 20)
}


// 运行结果：
[root@NEO example03_chan_goroute]# go run main/main.go
put data i:0
put data i:1
put data i:2
put data i:3
put data i:4
put data i:5
put data i:6
put data i:7
put data i:8
put data i:9
0
put data i:10
1
put data i:11
2
put data i:12
3
put data i:13
4
put data i:14
5
6
7
8
9
10
11
12
13
14
[root@NEO example03_chan_goroute]# 

// 上面代码的运行现象：同时开了 read() 和 write() 两个 goroutine，write() 中的前10个元素会立马写入到 管道 中，然后 write() 会阻塞，此时 read() 每秒读取一个，write() 再写入一个

channels 的关闭　　

// 示例代码：
package main

import (
    "fmt"    
)

func main(){
    var ch chan int
    ch = make(chan int,10)

    for i := 0; i < 10;  i++ {
        ch <- i
    }

    close(ch)        // 关闭管道；管道关闭后就不能再往管道里面写了，但是可以从管道里面读

    for {
        var b int
        b,ok :=<- ch        // ok 等于 false 表示这个管道已经关了 （将管道中的数据读取完后，才会返回false）
        if ok == false{
            fmt.Println("channel is closed")
            break
        }
        fmt.Println("ok:",ok)
        fmt.Println(b)
    }
}

// 运行结果：
[root@NEO example03_chan_close]# go run main/main.go
ok: true
0
ok: true
1
ok: true
2
ok: true
3
ok: true
4
ok: true
5
ok: true
6
ok: true
7
ok: true
8
ok: true
9
channel is closed
[root@NEO example03_chan_close]# 

// 关闭管道的相关官方解释：
// The loop for i := range c receives values from the channel repeatedly until it is closed.
// Channels aren't like files; you don't usually need to close them. Closing is only necessary when the receiver must be told there are no more values coming, such as to terminate a range loop.

关闭管道的参考链接：https://blog.csdn.net/Tovids/article/details/77867284

利用 for range 取出管道中所有的元素

// 示例代码：
package main

import "fmt"


func main(){
    var ch chan int
    ch = make(chan int,10)
    for i := 0; i < 10; i++ {
        ch <- i
    }

    close(ch)        // 把管道关闭，当 for range 取出管道中所有元素后就会自动退出 for range 循环
    for v := range ch{        // 利用 for range 取出管道中所有元素
        fmt.Println(v)
    }
}

// 运行结果：
[root@NEO example03_goroute_range]# go run main/main.go
0
1
2
3
4
5
6
7
8
9
[root@NEO example03_goroute_range]# 

chan 之间的同步

示例1：打印出1000以内的所有素数

// 示例代码：
package main

import (
    "fmt"
)


func calc(src chan int, res chan int, exitch chan bool){        // 检查是否为素数的函数
    for {
        v,ok :=<- src        // 从集合管道中取出一个元素
        if ok == false {    // 只有 src（intChan）close() 掉后，当 src（intChan）中所有元素取完后，ok 才会变成 false，所以 intChan 一定要关掉
            break
        }
        
        flag := true        // 是否为素数的标识符
        for i := 2; i < v; i++{
            if v % i == 0{
                flag = false
                break
            }
        }
        
        // 如果 flag == true，则为素数，添加到 res 管道中
        if flag {
            res <- v
        }
    }
    exitch <- true        // 线程执行完后，把 true 加到 exitch 中
}


func closeResChan(exitch chan bool,res chan int){
    for i := 0; i <8; i++{        // 如果 exitChan 管道中能取出8个元素，表示 calc() 那8个线程都已经执行完
        <- exitch        // 从 exitch 管道中取出一个元素（扔掉）
    }
    close(res)        // 关掉 resChan
}

func main(){
    var intChan chan int
    intChan = make(chan int,1000)
    var resChan chan int
    resChan = make(chan int,1000)        // 用于存放所有的素数
    var exitChan chan bool      
    exitChan = make(chan bool,8)    // 定义一个 exitChan 管道，用于判断上面的8个线程是否已经全部执行完

    for i := 2; i <= 1000; i++{        // 1000以内的数放到 intChan 管道中
        intChan <- i
    }
    close(intChan)        // 关闭管道

    // 把素数添加到 resChan 管道中
    for i := 0; i < 8; i++ {    // 假设电脑为8核，开启8个线程
        go calc(intChan, resChan, exitChan)
    }

    // 当上面新开的8个线程都执行完后，才应该把 resChan close() 掉
    go closeResChan(exitChan, resChan)

    // 从 resChan 管道中读取结果
    for v := range resChan{        // 为了不让 main 线程出现死锁，则应该先把 resChan close() 掉
        fmt.Println(v)
    }
    
}

// for v := range channel {}    // channel 管道也能 for range 来获取管道中的元素 ，v 表示取出来的 channel 中的元素

示例2：一个线程发送数据，一个线程接收数据

// 示例代码：
package main

import "fmt"

func send(intChan chan int, exitChan chan bool){
    for i := 0; i < 10; i++{
        intChan <- i
    }
    close(intChan)            // 写入完成之后，关闭 intChan，这样 for range intChan 时取出数据后 才会自动退出
    exitChan <- true         // 表示 send() 线程已经执行完毕
}

func recv(intChan chan int, exitChan chan bool){
    for v := range intChan{        // 由于 send() 中已经关闭了 intChan，所以当 intChan 中的数据取完后，该 for range 会自动退出
        fmt.Println(v)
    }
    
    exitChan <- true
}

func main(){
    var intChan chan int
    intChan = make(chan int,10)
    var exitChan chan bool
    exitChan = make(chan bool,2)    // 用于标识程序退出；长度 2 表示最多标识2个线程

    go send(intChan, exitChan)
    go recv(intChan, exitChan)

    for i := 0; i < 2; i++ {
        <- exitChan
    }
}

// 运行结果：
[root@NEO example03_goroute_sync02]# go run main/main.go
0
1
2
3
4
5
6
7
8
9
[root@NEO example03_goroute_sync02]# 

chan 的只读和只写

a. 只读 chan 的声明
    var 变量名字 <-chan int
    var readChan <-chan int

b. 只写 chan 的声明
    var 变量名字 chan<- int
    var writeChan chan<- int

channels 的 select 操作

select 用于多个channel监听并收发消息，当任何一个case满足条件则会执行，若没有可执行的case，就会执行default，如果没有default，程序就会阻塞。
// 语法示例：
select {
case i := <-c:
    // use i
default:
    // receiving from c would block
}

示例代码：

package main

import (
    "fmt"
    "time"
)

func main(){
    var ch01 chan int
    ch01 = make(chan int,10)
    ch02 := make(chan int,10)

    go func(){
        var i int
        for {
            ch01 <- i
            time.Sleep(time.Second)
            ch02 <- i * i
            time.Sleep(time.Second)
            i++ 
        }
    }()

    for {
        select {            // 哪个管道里面有数据，就走哪个 case；所有管道都没数据，就走 default
        case v :=<- ch01:
            fmt.Println("ch01 ele:",v)
        case v :=<- ch02:
            fmt.Println("ch02 ele:",v)
        default:
            fmt.Println("get data timeout")
            time.Sleep(time.Second)
        }
    }
}


// 运行结果：
[root@NEO example03_goroute_select]# go run main/main.go
get data timeout
ch01 ele: 0
ch02 ele: 0
get data timeout
get data timeout
ch01 ele: 1
ch02 ele: 1
get data timeout
get data timeout
ch02 ele: 4
ch01 ele: 2
get data timeout
get data timeout
ch01 ele: 3
ch02 ele: 9
get data timeout
get data timeout
ch01 ele: 4
ch02 ele: 16
get data timeout
^Csignal: interrupt
[root@NEO example03_goroute_select]# 

 

定时器

// 语法示例1： NewTicker()
t := time.NewTicker(time.Second)    // NewTicker() 中的参数是执行的时间间隔（多久触发一次） --> 可作超时控制（推荐）
for v := range t.C {                // t.C 是一个 channel，背后也是个 goroutine
    fmt.Println("hello,",v)
}
// time.NewTicker() 用完之后要关掉  --> t.Stop() 

// 示例2：time.After()
select {
    case  <- time.After(time.Second):        // 一秒之后会执行一下，然后以后就不会再触发 --> 可用于设置超时时间控制
        fmt.Println("after")
}
// 系统会回收 time.After() 的资源（性能不如 time.NewTicker() 的 t.Stop() 好）

// 推荐使用 time.NewTicker()

time.NewTicker() 示例：

// 示例代码1：
package main

import (
    "fmt"
    "time"
)

func main(){
    t := time.NewTicker(time.Second)
    for v := range t.C {
        fmt.Println("hello,",v)
    }
}

// 运行结果：
[root@NEO example04_time_newticker01]# go run main/main.go
hello, 2019-08-11 02:46:37.940256992 +0800 CST m=+1.000517671
hello, 2019-08-11 02:46:38.940289529 +0800 CST m=+2.000550209
hello, 2019-08-11 02:46:39.940339135 +0800 CST m=+3.000599804
hello, 2019-08-11 02:46:40.940363886 +0800 CST m=+4.000624567
hello, 2019-08-11 02:46:41.940399863 +0800 CST m=+5.000660552
^Csignal: interrupt
[root@NEO example04_time_newticker01]# 

// 示例代码2：
package main

import (
    "fmt"
    "time"
)

func main(){
    var ch01 chan int
    ch01 = make(chan int,10)
    ch02 := make(chan int,10)

    t := time.NewTicker(time.Second)

    select {
    case v :=<- ch01:
        fmt.Println("ch01 ele:",v)
    case v :=<- ch02:
        fmt.Println("ch02 ele:",v)
    case <- t.C:        // 超时控制
        fmt.Println("get data timeout")
    }
    t.Stop()    // 关闭 定时器
}

// 运行结果：
[root@NEO example04_time_newticker02]# go run main/main.go
get data timeout                // 1秒后输出了这条结果
[root@NEO example04_time_newticker02]# 

time.After() 示例：

// 示例代码：
package main

import (
    "fmt"
    "time"
)

func main(){
    var ch01 chan int
    ch01 = make(chan int,10)
    ch02 := make(chan int,10)

    select {
    case v :=<- ch01:
        fmt.Println("ch01 ele:",v)
    case v :=<- ch02:
        fmt.Println("ch02 ele:",v)
    case <- time.After(time.Second):        // 设置超时时间控制
        fmt.Println("get data timeout")
    }
}

// 运行结果：
[root@NEO main]# go run main.go
get data timeout                        // 1秒后输出了这条结果
[root@NEO main]# 

 

goroutine 的 recover

// 如果 goroutine 中有 panic ，那整个程序也会崩溃，如下：
// 示例代码：
package main

import (
    //"fmt"
    "time"
)

func test(){
    var m map[string]string        // 只声明未初始化，直接使用会 panic
    m["name"] = "stu01"            // goroutine 会 panic
}

func main(){
    for i := 0; i < 10; i++{
        go test()
    }    
    time.Sleep(time.Second * 10)
}

// 运行结果：
[root@NEO example05_goroutine_panic]# go run main/main.go
panic: assignment to entry in nil map

goroutine 4 [running]:
main.test()
    /root/go/project/src/go_dev/day08/example05_goroutine_panic/main/main.go:10 +0x4b
created by main.main
    /root/go/project/src/go_dev/day08/example05_goroutine_panic/main/main.go:15 +0x3e
exit status 2
[root@NEO example05_goroutine_panic]# 

异常捕获： recover()

// 示例代码：
package main

import (
    "fmt"
    "time"
)

func test(){
    
    defer func(){        // 进行异常捕获的匿名函数
        err := recover()        // recover()  --> 捕获异常
        if err != nil {
            fmt.Println("panic:",err)
        }
    }()

    var m map[string]string        // 只声明未初始化，直接使用会 panic
    m["name"] = "stu01"
}

func main(){
    for i := 0; i < 10; i++{
        go test()
    }    
    time.Sleep(time.Second * 10)
}

// 运行结果：
[root@NEO example05_goroutine_panic]# go run main/main.go
panic: assignment to entry in nil map        // 虽然 goroutine 中有异常，但由于做了异常捕获，主线程不会挂掉 （主线程和其他 goroutine 不受影响）
panic: assignment to entry in nil map
panic: assignment to entry in nil map
panic: assignment to entry in nil map
panic: assignment to entry in nil map
panic: assignment to entry in nil map
panic: assignment to entry in nil map
panic: assignment to entry in nil map
panic: assignment to entry in nil map
panic: assignment to entry in nil map
[root@NEO example05_goroutine_panic]# 

 

单元测试

1. 文件名必须以 _test.go 结尾
2. 使用 go test 命令进行测试；
3. _test.go 文件中的测试函数必须以 Test    开头
4. 传入的参数 *testing.T