当从缓冲通道读取时，所有的goroutine都处于休眠状态。

huangapple
go评论144阅读模式
英文:

All goroutines are asleep when reading from buffered channel

问题

  1. func writeToChan(wg *sync.WaitGroup, ch chan int, stop int) {
  2.     defer wg.Done()
  3.     for i := 0; i < stop; i++ {
  4.         ch <- i
  5.     }
  6. }
  8. func readToChan(wg *sync.WaitGroup, ch chan int) {
  9.     defer wg.Done()
  10.     for n := range ch {
  11.         fmt.Println(n)
  12.     }
  13. }
  15. func main() {
  16.     ch := make(chan int, 3)
  17.     wg := new(sync.WaitGroup)    
  19.     wg.Add(2)
  20.     go writeToChan(wg, ch, 5)
  21.     go readToChan(wg, ch)
  23.     wg.Wait()
  24. }
  1. 0
  2. 1
  3. 2
  4. 3
  5. 4
  6. fatal error: all goroutines are asleep - deadlock!

我假设readToChan函数总是连续读取，而writeToChan函数在向通道写入数据后会等待通道被读取。
我不知道为什么输出显示死锁，尽管我已经在WaitGroup中添加了两个wait操作。

英文: 
  2. func writeToChan(wg *sync.WaitGroup, ch chan int, stop int) {
  3.     defer wg.Done()
  4.     for i := 0; i &lt; stop; i++ {
  5.         ch &lt;- i
  6.     }
  7. }
  9. func readToChan(wg *sync.WaitGroup, ch chan int) {
  10.     defer wg.Done()
  11.     for n := range ch {
  12.         fmt.Println(n)
  13.     }
  14. }
  16. func main() {
  17.     ch := make(chan int, 3)
  18.     wg := new(sync.WaitGroup)    
  21.     wg.Add(2)
  22.     go writeToChan(wg, ch, 5)
  23.     go readToChan(wg, ch)
  25.     wg.Wait()
  26. }
  1. 0
  2. 1
  3. 2
  4. 3
  5. 4
  6. fatal error: all goroutines are asleep - deadlock!

I assume that the readToChan always reads continuously, and the writeToChan write to the channel and waits while the channel is read.
I don't know why the output showed deadlock while I added two 'wait' to the WaitGroup.

答案1

得分: 2

你需要在发送方关闭通道。
使用以下代码：

  1. for n := range ch {
  2.     fmt.Println(n)
  3. }

只有当ch被关闭时，循环才会停止。

正确的示例代码如下：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"sync"
  6. )
  8. func writeToChan(wg *sync.WaitGroup, ch chan int, stop int) {
  9.     defer wg.Done()
  10.     for i := 0; i < stop; i++ {
  11.         ch <- i
  12.     }
  13.     close(ch)
  14. }
  16. func readToChan(wg *sync.WaitGroup, ch chan int) {
  17.     defer wg.Done()
  18.     for n := range ch {
  19.         fmt.Println(n)
  20.     }
  21. }
  23. func main() {
  24.     ch := make(chan int, 3)
  25.     wg := new(sync.WaitGroup)    
  28.     wg.Add(2)
  29.     go writeToChan(wg, ch, 5)
  30.     go readToChan(wg, ch)
  32.     wg.Wait()
  33. }
英文:

You need to close channel at the sender side.
By using

  1. for n := range ch {
  2.     fmt.Println(n)
  3. }

The loop will only stop when ch is closed

correct example:

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;sync&quot;
  6. )
  8. func writeToChan(wg *sync.WaitGroup, ch chan int, stop int) {
  9.     defer wg.Done()
  10.     for i := 0; i &lt; stop; i++ {
  11.         ch &lt;- i
  12.     }
  13.     close(ch)
  14. }
  16. func readToChan(wg *sync.WaitGroup, ch chan int) {
  17.     defer wg.Done()
  18.     for n := range ch {
  19.         fmt.Println(n)
  20.     }
  21. }
  23. func main() {
  24.     ch := make(chan int, 3)
  25.     wg := new(sync.WaitGroup)    
  28.     wg.Add(2)
  29.     go writeToChan(wg, ch, 5)
  30.     go readToChan(wg, ch)
  32.     wg.Wait()
  33. }

答案2

得分: 0

如果没有在缓冲通道上调用close函数，读取器就不知道何时停止读取。请查看以下示例，其中使用for和select调用来处理多个通道。

https://go.dev/play/p/Lx5g9o4RsqW

  1. package main
  2. import (
  3. 	"fmt"
  4. 	"sync"
  5. 	"time"
  6. )
  8. func writeToChan(wg *sync.WaitGroup, ch chan int, stop int, quit chan<- bool) {
  9. 	defer func() {
  10. 		wg.Done()
  11. 		close(ch)
  12. 		fmt.Println("write wg done")
  13. 	}()
  15. 	for i := 0; i < stop; i++ {
  16. 		ch <- i
  17. 		fmt.Println("write:", i)
  18. 	}
  20. 	fmt.Println("write done")
  21. 	fmt.Println("sleeping for 5 sec")
  22. 	time.Sleep(5 * time.Second)
  23. 	quit <- true
  24. 	close(quit)
  25. }
  27. func readToChan(wg *sync.WaitGroup, ch chan int, quit chan bool) {
  28. 	defer func() {
  29. 		wg.Done()
  30. 		fmt.Println("read wg done")
  31. 	}()
  33. 	for {
  34. 		select {
  35. 		case n := <-ch:
  36. 			fmt.Println("read:", n)
  37. 		case val := <-quit:
  38. 			fmt.Println("received quit:", val)
  39. 			return
  40. 		}
  41. 	}
  42. }
  44. func main() {
  45. 	ch := make(chan int, 5)
  46. 	ch2 := make(chan bool)
  47. 	wg := new(sync.WaitGroup)
  48. 	wg.Add(2)
  50. 	go writeToChan(wg, ch, 3, ch2)
  51. 	go readToChan(wg, ch, ch2)
  53. 	wg.Wait()
  54. }

输出：

  1. write: 0
  2. write: 1
  3. write: 2
  4. write done
  5. sleeping for 5 sec
  6. read: 0
  7. read: 1
  8. read: 2
  9. write wg done
  10. received quit: true
  11. read wg done
  13. 程序已退出。
英文:

If close is not called on buffered channel, reader doesn't know when to stop reading.
Check this example with for and select calls(to handle multi channels).

https://go.dev/play/p/Lx5g9o4RsqW

  1.     package main 
  2.     import (
  3.     &quot;fmt&quot;
  4.     &quot;sync&quot;
  5.     &quot;time&quot;) 
  6. func writeToChan(wg *sync.WaitGroup, ch chan int, stop int, quit chan&lt;- bool) {
  7.     defer func() {
  8.     	wg.Done()
  9.     	close(ch)
  10.     	fmt.Println(&quot;write wg done&quot;)
  11.     
  12.     }()
  13.     for i := 0; i &lt; stop; i++ {
  14.     	ch &lt;- i
  15.     	fmt.Println(&quot;write:&quot;, i)
  16.     }
  17.     fmt.Println(&quot;write done&quot;)
  18.     fmt.Println(&quot;sleeping for 5 sec&quot;)
  19.     time.Sleep(5 * time.Second)
  20.     quit &lt;- true
  21.     close(quit)
  22. }
  23. func readToChan(wg *sync.WaitGroup, ch chan int, quit chan bool) {
  24.     defer func() {
  25.     	wg.Done()
  26.     	fmt.Println(&quot;read wg done&quot;)
  27.     }()
  28.     //using rang over
  29.     //for n := range ch {
  30.     //	fmt.Println(n)
  31.     //}
  32.     //using Select if you have multiple channels.
  33.     for {
  34.     	//fmt.Println(&quot;waiting for multiple channels&quot;)
  35.     	select {
  36.     	case n := &lt;-ch:
  37.     		fmt.Println(&quot;read:&quot;, n)
  38.     		// if ok == false {
  39.     		// 	fmt.Println(&quot;read done&quot;)
  40.     		// 	//return
  41.     		// }
  42.     	case val := &lt;-quit:
  43.     		fmt.Println(&quot;received quit :&quot;, val)
  44.     		return
  45.     		// default:
  46.     		// 	fmt.Println(&quot;default&quot;)
  47.     	}
  48.     }
  49. }
  50. func main() {
  51.     ch := make(chan int, 5)
  52.     ch2 := make(chan bool)
  53.     wg := new(sync.WaitGroup)
  54.     wg.Add(2)
  55.     go writeToChan(wg, ch, 3, ch2)
  56.     go readToChan(wg, ch, ch2)
  57.     wg.Wait()
  58. }

Output:

  1. write: 0
  2. write: 1
  3. write: 2
  4. write done
  5. sleeping for 5 sec
  6. read: 0
  7. read: 1
  8. read: 2
  9. write wg done
  10. received quit : true
  11. read wg done
  13. Program exited.

huangapple
  • 本文由 发表于 2022年8月16日 13:34:52
  • 转载请务必保留本文链接：https://go.coder-hub.com/73369181.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定