ch8/ch8-04

[giscus[bot]]

ch8/ch8-04

中文版

https://gopl-zh.github.io/ch8/ch8-04.html

[zhangbest5]

无缓冲通道必须在单独goroutine工作，在main中会死锁，个人总结：

func main() {
	ch := make(chan int, 1)
	//ch <- 1 //错误 死锁
    go func() { ch <- 1 }() //正确，必须单独在一个goroutine中使用
    //close(ch) //错误，关了，读不出来了
	<-ch
    close(ch) //正确，
	fmt.Println("End")

[0sunshine]

总结的很好，下次不要总结了，免得误导人，有缓存的chan，你后续的ch <- 1 明显不会死锁

[haiki]

人家说的就是对的好么？out := make(chan int) 是无缓存chan。
一个基于无缓存Channels的发送操作将导致发送者goroutine阻塞，直到另一个goroutine在相同的Channels上执行接收操作。

执行 out <- 2 后，main 就阻塞着等待这个out中的内容被取走才会继续执行下面的语句，而go f1(out) 始终无法被执行到，也就无法消费out中的内容，互相等待导致死锁。

[amosnothing]

func main() {
	ch := make(chan int, 1)
	ch <- 1 // 错误 死锁       
    // go func() { ch <- 1 }() //正确，必须单独在一个goroutine中使用
    //close(ch) //错误，关了，读不出来了
	<-ch
    close(ch) //正确，
	fmt.Println("End") 
}

main 函数里面的第二行的死锁怎么来的？搞错了吧

[xianren68]

第二行因为没有协程接收它，会直接卡在哪里，因为它没有缓冲区，会一直等待有其他协程来读取这个值

[ReReniao]

第二个错误并不是因为close导致读不出来而panic，而是在第一个goroutine向chan中写之前就close了，导致第一个goroutine向关闭的chan写而panic。

func main() {
	ch := make(chan int, 1)
	//ch <- 1 //错误 死锁
    go func() { ch <- 1 }() //正确，必须单独在一个goroutine中使用
	time.Sleep(time.Millisecond) // 等待协程写完成
    close(ch) 
	<-ch // 关闭的有缓存chan依旧可读
    // close(ch) //正确，
	fmt.Println("End")
}

[zhangbest5]

这里必须使用range,for取完了，即使关闭了通道，在goroutine内还是会取到0值
···
func main() {
naturals := make(chan int)
squares := make(chan int)

// Counter
go func() {
	for x := 0; x < 10; x++ {
		naturals <- x
		fmt.Println("x:", x)
	}
	close(naturals)
	panic("game over")
}()

// Squarer
go func() {
	for {
		x := <-naturals
		fmt.Println("x_out:", x)
		squares <- x * x
	}
	close(squares)
}()

// Printer (in main goroutine)
for x := range squares {
	fmt.Println(x)
}

}
···

最后输出
...
x: 9
x_out: 0
x_out: 0
panic: game over

[zhangbest5]

类型chan<- int表示一个只发送int的channel，只能发送不能接收。
相反，类型<-chan int表示一个只接收int的channel，只能接收不能发送。
（箭头<-和关键字chan的相对位置表明了channel的方向。）
这里翻译得很有歧义，而且很多书都爱反着说：
实际上：
类型chan<- int 表示：只能把int数据放入channel ，只能写入不能读取
类型<-chan int表示：只能从channel中读取int，只能读取不能写入
（箭头<-理解为数据的走向，和关键字chan的相对位置表明了channel能读取，还是写入）
中文真是好难理解，上下两端话完全反了过来，但是一个意思，真是神奇，而且在我看来in 和out变量名也该对调下，更好理解。要不太绕了

[zhangbest5]

在 8.4.3. 单方向的Channel 的第四自然段

[haiki]

确实，看文中翻译有点难理解，刚找到一个比较好的解释：
chan<- 表示数据进入管道，要把数据写进管道，对于调用者就是输出，参数就是out。
<-chan 表示数据从管道出来，对于调用者就是得到管道的数据，当然就是输入，参数就是in。

[Etherealss]

确实，采用你的说法更好理解！

[whaliendev]

一段使用go协程和channel写的埃氏筛

package main

import (
	"fmt"
	"math"
	"time"
)

const (
	UPPER = 1e2
)

func source(out chan<- int) {
	for i := 2; i <= UPPER; i++ {
		out <- i
	}
	close(out)
}

func cull(p int, in <-chan int, out chan<- int) {
	for n := range in {
		if n%p != 0 {
			out <- n
		}
	}

	close(out)
}

func sink(in <-chan int) {
	for {
		p, ok := <-in
		if !ok {
			break
		}

		fmt.Print(p, " ")

		ch := make(chan int)
		go cull(p, in, ch)
		in = ch
	}
}

func timer(name string) func() {
	start := time.Now()
	return func() {
		fmt.Printf("%s took %v to execute\n", name, time.Since(start))
	}
}

// sieve of Eratosthene
// ref: https://www.cs.dartmouth.edu/~doug/sieve/sieve.pdf
func csp() {
	defer timer("csp")()
	ch := make(chan int)
	go source(ch)
	sink(ch)
	fmt.Println()
}

func plainPrime() {
	defer timer("plainPrime")()
	for i := 2; i <= UPPER; i++ {
		isPrime := true
		for j := 2; j <= int(math.Sqrt(float64(i))); j++ {
			if i%j == 0 {
				isPrime = false
				break
			}
		}
		if isPrime {
			fmt.Printf("%d ", i)
		}
	}
	fmt.Println()
}

func main() {
	csp()
	plainPrime()
}

[xianren68]

8.3

package main

import (
	"io"
	"log"
	"net"
	"os"
)

func main() {
	conn, err := net.Dial("tcp", ":8088")
	if err != nil {
		log.Fatal(err)
	}
	// 空结构体尺寸为0,通常当作信号来传播
	ch := make(chan struct{})
	go func() {
		io.Copy(os.Stdout, conn)
		log.Println("done")
		// 发送信号，让等待阻塞的main函数继续执行
		ch <- struct{}{}
	}()
	mustCopy(conn, os.Stdin)
	// 标准输入流关闭后，关闭conn的输入流
	conn.(*net.TCPConn).CloseWrite()
	// 阻塞等待服务端消息结束
	<-ch
}

func mustCopy(dst io.Writer, src io.Reader) {
	_, err := io.Copy(dst, src)
	// 注释这里，不然读取到eof会直接退出程序
	// log.Fetal(err)
}

[LuVsLu]

当一个被关闭的channel中已经发送的数据都被成功接收后，后续的接收操作将不再阻塞，它们会立即返回一个零值。这个设计容易埋坑啊。

[coderZoe]

合理的吧，如果不直接返回零值要怎么设计呢？设计成阻塞那就会存在死锁问题，设计成panic那还不如返回零值

[lazybearlee]

操作不同状态的chan会引发三种行为：

• panic
  1. 向已经关闭的通道写数据
  2. 重复关闭通道
• 阻塞
  1. 向未初始化的通道写/读数据
  2. 向缓冲区已满的通道写入数据
  3. 通道中没有数据，读取该通道
• 非阻塞
  1. 读取已经关闭的通道，这个操作会返回通道元素类型的零值（可用comma, ok语法）
  2. 向有缓冲且没有满的通道读/写

[lazybearlee]

测试

package main

import (
	"testing"
)

func TestChanOperateStatus(t *testing.T) {
	t.Run("向已经关闭的通道写数据", func(t *testing.T) {
		ch := make(chan int)
		close(ch) // 关闭通道
		ch <- 1   // 这里会引发panic，因为向已关闭的通道发送数据
		// panic: send on closed channel [recovered]
	})
	t.Run("重复关闭通道", func(t *testing.T) {
		ch := make(chan int)
		close(ch) // 第一次关闭通道
		close(ch) // 再次关闭通道会引发panic
		// panic: close of closed channel [recovered]
	})
	t.Run("向未初始化的通道写/读数据", func(t *testing.T) {
		var ch chan int
		go func() {
			ch <- 1
			// x := <-ch
		}()
		_ = <-ch
		// fatal error: all goroutines are asleep - deadlock!
	})
	t.Run("向缓冲区已满的通道写入数据", func(t *testing.T) {
		ch := make(chan int, 1)
		ch <- 1 // 第一次写入，缓冲区未满
		ch <- 2 // 这里会阻塞，因为缓冲区已满，没有goroutine读取数据
		// fatal error: all goroutines are asleep - deadlock!
	})
	t.Run("通道中没有数据，读取该通道", func(t *testing.T) {
		ch := make(chan int)
		_ = <-ch // 这里会阻塞，因为没有goroutine发送数据到通道
		// fatal error: all goroutines are asleep - deadlock!
	})
	t.Run("读取已经关闭的通道，这个操作会返回通道元素类型的零值（可用comma, ok语法）", func(t *testing.T) {
		ch := make(chan int)
		close(ch)     // 关闭通道
		x, ok := <-ch // x 将会是int类型的零值，ok 将会是false
		expectx, expectok := 0, false
		if ok != expectok && x != expectx {
			t.Errorf("expect 0, false, get %d, %t\n", x, ok)
		}
	})
	t.Run("向有缓冲且没有满的通道写，向有缓冲且不为空的通道读", func(t *testing.T) {
		ch := make(chan int, 2) // 1 也不会堵塞
		ch <- 1                 // 写入数据，不会阻塞
		_ = <-ch                // 读取数据，不会阻塞
	})
}