Go 并发编程 - channel 小结

简介

使用通信(channel)来共享内存，而不是通过共享内存来通信

初始化

除了 channel 以外，make 还可以用来初始化 slice、map

ch1 := make(chan int, 3) // 初始化一个大小为 3 的 channel
ch2 := make(chan int)    // 初始化一个无缓冲的 channel

• 队列满时生产者阻塞

• 队列空时消费者阻塞

func TestChannel(t *testing.T) {
	ch2 := make(chan int)
	ch2 <- 1
	fmt.Println(<-ch2)
}

func TestChannel(t *testing.T) {
	ch2 := make(chan int)
	go func() {
		fmt.Println(<-ch2)
	}()
	ch2 <- 1
}

func TestChannel(t *testing.T) {
	ch2 := make(chan int)
	ch2 <- 1 // 提前发送, deadlock
	go func() {
		fmt.Println(<-ch2)
	}()
}

channel 的使用

遍历

func TestFor(t *testing.T) {
	ch1 := make(chan int, 100)
	for i := 0; i < 100; i++ {
		ch1 <- i
	}
	
	// 方式一, 用 for 取出所有元素，建议使用
	for i := range ch1 {
		fmt.Println(i)
	}
	fmt.Println("-")

	// 方式二
	for {
		i, ok := <-ch1 // 通道关闭后再取值ok=false
		if !ok {
			break
		}
		fmt.Println(i)
	}
}

select

func fibonacci(c, quit chan int) {
	x, y := 0, 1
	for {
		select {
		case c <- x:
			x, y = y, x+y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func TestSelect(t *testing.T) {
	c := make(chan int)
	quit := make(chan int)
	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()
	fibonacci(c, quit)
}
// output:
//0
//1
//1
//2
//3
//5
//8
//13
//21
//34
//quit

func TestTimeout(t *testing.T) {
	c1 := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 2)
		c1 <- "result 1"
	}()
	select {
	case res := <-c1:
		fmt.Println(res)
	case <-time.After(time.Second * 1):
		fmt.Println("timeout 1")
	}
}
// output:
// timeout 1

func After(d Duration) <-chan Time {
	return NewTimer(d).C
}

通道的限制

func op(writer <-chan int, reader chan<- int) {
	for data := range writer{
		reader <- data
	}
}

通道的关闭和异常

func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	defer func(){
		close(ch)
	}()
	// do something ... 
}

// 无缓冲 channel，读
func TestClose(t *testing.T) {
	ch := make(chan int)
	close(ch)
	fmt.Println(<-ch) // 0
}

// 无缓冲 channel，写
func TestClose(t *testing.T) {
	ch := make(chan int)
	close(ch)
	ch <- 0 // panic: send on closed channel
}

// 有缓冲 channel, 无写入值， 读
func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	close(ch)
	fmt.Println(<-ch) // 0
}

// 有缓冲 channel，有写入值，读
func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	for i := 1; i <= 10; i++ {
		ch <- i
	}
	close(ch)
	for i := range ch {
		fmt.Println(i) // 输出 1 到 10
	}
	fmt.Println(<-ch) // 输出 0
}

// 有缓冲 channel, 写
func TestClose(t *testing.T) {
	ch := make(chan int, 10)
	close(ch)
	ch <- 1 // panic: send on closed channel
}

func TestClose(t *testing.T) {
	ch := make(chan int, 1)
	ch = nil
	fmt.Println(<-ch) // fatal error: all goroutines are asleep - deadlock!
	ch <- 1           // fatal error: all goroutines are asleep - deadlock!
	close(ch)         // panic: close of nil channel
}

源码分析

Ref