go-channel

无缓冲区channel

hchan.buff是个nil值，没有数据存储的区域，肯定会出现阻塞现象

• 写操作：去hchan.recvq队列中去获取一个正阻塞的协程sudog结构变量
  • 如果hchan.recvq有数据，则根据sudog.g变量去唤醒协程，并向这个协程发送数据
  • 如果hchan.recvq有数据，则创建一个sudog结构体变量，sudog.g变量指向当前协程，放到hchan.sendq队列，当前goroutine阻塞(被挂起_GWating)
• 读操作：和写操作差不多，只是操作hchan.recvq

唤醒阻塞协程对channel做操作，都是由当前协程通知g0协程做调度

多路select

问题：为什么多个case被阻塞，说明当前g被加到了多个hchan.recvq或者hchan.sendq中，为什么只会执行一个case。

func SendBlock2() {
	c1 := make(chan int)
    c2 := make(chan int)
    // go不能放select后，因为执行顺序的问题，如果放后面在select就挂起了协程，导致没有创建这个协程，也就不可能唤醒当前协程，从而导致死锁
	go func() {
		time.Sleep(3 * time.Second)
		a := <-c1
		fmt.Println(a)
	}()
    
	select {
	case c1 <- 2:
		fmt.Println("case1")
	case c2 <- 3:
		fmt.Println("case2")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

上例的现象是：打印了case1或者case2，并不会两个都打印。

执行步骤：

1. 执行case1时给c1加锁，执行case2时给c2加锁
2. select乱序轮询
3. g被加到c1和c2的 hchan.sendq中，c1和c2解锁允许其他协程操作这个channel，g被挂起等待
4. 子协程命中唤醒主协程，命中case1，执行case1操作
5. 再次对所有case的channel加锁（原因是下一步）
6. 去c1,c2的recvq和sendq遍历删除绑定了当前协程的sudog，因为删除了队列中的等待g，所以g不会被重新唤醒，case2就再也不命中。
7. c1,c2再次解锁
8. select结束

使用语法

创建channel

// 方法1，没有分配地址，无法读写chan
var c chan Type

// 方法2，分配了地址，设置了size就是有缓冲channel,反之是无缓冲地址
c := make(chan Type [, size])
1
2
3
4
5

写channel

c := make(chan Type [, size])

// 方法1
c <- val

// 方法2
select {
    case c<-2:
    // 下一个
    case c<-2:
    //业务逻辑
    default:
    //可以避免阻塞
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

读channel

c := make(chan Type [, size])

// 方法1
t := <-c

// 方法2
t,ok := <-c 	// ok==false表明，chan被关闭

// 方法3
select {
    case <-c:
    //业务逻辑
    default:
    //可以避免阻塞
}

// 方法4
for element := range c {
    fmt.Println("chan element:", element)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

关闭channel

close(c)
1

具体案例

有缓冲区channel

func SendBlock1() {
    // 创建缓冲区容量是3的通道
	c := make(chan int, 3)
	defer close(c)
    // 创建4个协程往通道里写，会有一个协程阻塞等待
	for i := 0; i < 4; i++ {
		
		go func(i int) {
			c <- i
			fmt.Printf("i=%d成功插入chan\n", i)
		}(i)	// 如果i不使用传参方式，而是使用闭包函数，那么就会发生数据逃逸，i会被存到堆中，栈帧上的i变成指针指向堆，导致协程里的i不一定打印0,1,2,3
	}
	time.Sleep(3 * time.Second)

	//打印，2协程阻塞等待
	//i=3成功插入chan
	//i=0成功插入chan
	//i=1成功插入chan
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

无缓冲区channel

func SendBlock() {
	c := make(chan int)
	defer close(c)
	for i := 0; i < 4; i++ {
		// 如果i不使用传参方式，而是使用闭包函数，那么就会发生数据逃逸，i会被存到堆中，栈帧上的i变成指针指向堆，导致协程里的i不一定打印0,1,2,3
		go func(i int) {
			c <- i
			fmt.Printf("i=%d成功插入chan\n", i)
		}(i)
	}
	time.Sleep(3 * time.Second)

	//没有任何打印，因为hchan.recvq没有协程可以唤醒

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用注意

• 对一个关闭的channel发送值 panic
• 对一个关闭的channel接收值，会一直读取成功，直到管道内数据为空
• 对一个关闭的并且没有值的管道执行接收操作，会得到对应类型的空值
• 关闭一个已关闭的通道会导致panic
• 关闭一个chan，会向所有正在监听这个chan的协程都发送一个空元素(元素类型取决于你的chan类型)

死锁：

func f1(channel chan int) {
    time.Sleep(6 * time.Second)
	channel <- 20
	//close(channel)
}

func main() {
	channel := make(chan int)

    //例1 不会死锁,因为读写都只进行了一次之后就结算了
	go func() {
        time.Sleep(6 * time.Second)
		channel <- 20
	}()
	fmt.Println(<-channel)	// 主协程会阻塞等待管道进入数据
    
    //例2 不会死锁,因为读写都只进行了一次之后就结算了
	go f1(channel)
    fmt.Println(<-channel)

    //例3 不会死锁,因为读写都只进行了一次之后就结算了
	go func(channel chan int) {
		channel <- 20
	}(channel)
	fmt.Println(<-channel)
    
    //例4 会死锁,主协程会一直等待子进程写入,无法退出,此时需要在子协程加入close(channel),表明自己不会在对协程做操作了
    go func(channel chan int) {
		channel <- 20
        // close(channel) 加上则不会死锁
	}(channel)
    for element := range channel {
		fmt.Println(element)
	}
    
    
    //例子5,结果是等待3秒后,其中一个消费协程会被死锁,因为他一直在等待channel的数据进入
    channel := make(chan int, 3)

	wg := sync.WaitGroup{}
	wg.Add(3)
	go func() {
		defer wg.Done()
		//fmt.Println("子协程1")
		fmt.Println("子协程1抢到的" + strconv.Itoa(<-channel))
	}()
	go func() {
		defer wg.Done()
		//fmt.Println("子协程2")
		fmt.Println("子协程2抢到的" + strconv.Itoa(<-channel))

	}()
	go func() {
		defer wg.Done()
		channel <- 20
		for i := 0; i < 3; i++ {
			time.Sleep(time.Second)
		}
	}()

	//channel <- 21
	wg.Wait()
}
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63