Housie程序中的死锁。生产者-消费者模式

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

Deadlock in Housie Program. Producer-Consumer Pattern

问题

我正在尝试实现一个 housie 游戏，其中一个 goroutine 生成数字，另外三个 goroutine 检查这些数字是否在它们的令牌中，并在所有数字都被生成后通知生成者。我已经用以下方式在 Golang 中实现了它。这导致了死锁。有什么想法为什么会发生这种情况吗？这是一个“作业问题”，我只是为了更好地学习 Go 而实现它。

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"math/rand"
  6. )
  8. type PersonID int
  10. func contains(s []int, e int) bool {
  11. 	for _, a := range s {
  12. 		if a == e {
  13. 			return true
  14. 		}
  15. 	}
  16. 	return false
  17. }
  19. func Person(called_number chan int, claim_prize chan PersonID, received chan bool, coupon []int, person_id PersonID) {
  20. 	numFound := 0
  21. 	for i := 0; i < len(coupon); i++ {
  22. 		current_number := <-called_number
  23. 		found := contains(coupon, current_number)
  24. 		if found {
  25. 			numFound++
  26. 		}
  27. 		if numFound == len(coupon) {
  28. 			claim_prize <- person_id
  29. 		} else {
  30. 			received <- true
  31. 		}
  32. 	}
  33. }
  35. func main() {
  36. 	var called_number chan int
  37. 	var claim_prize chan PersonID
  38. 	var received chan bool
  40. 	tokens := make([][]int, 3)
  41. 	for i := 0; i < 3; i++ {
  42. 		tokens[i] = make([]int, 12)
  43. 		for j := 0; j < 12; j++ {
  44. 			num := rand.Intn(100) + 1
  45. 			found := contains(tokens[i], num)
  46. 			for found {
  47. 				num = rand.Intn(100) + 1
  48. 				found = contains(tokens[i], num)
  49. 			}
  50. 			tokens[i][j] = num
  51. 		}
  52. 	}
  54. 	go Person(called_number, claim_prize, received, tokens[0], 0)
  55. 	go Person(called_number, claim_prize, received, tokens[1], 1)
  56. 	go Person(called_number, claim_prize, received, tokens[2], 2)
  58. 	claimants := make([]PersonID, 0)
  59. 	prev_called := make(map[int]bool)
  60. 	for i := 0; i < 100; i++ {
  61. 		if len(claimants) == 3 {
  62. 			break
  63. 		}
  64. 		num := rand.Intn(100) + 1
  65. 		_, ok := prev_called[num]
  66. 		for ok {
  67. 			num = rand.Intn(100) + 1
  68. 			_, ok = prev_called[num]
  69. 		}
  70. 		prev_called[num] = true
  71. 		called_number <- num
  72. 		for j := 0; j < 3; j++ {
  73. 			select {
  74. 			case _ = <-received:
  75. 				continue
  76. 			case pid := <-claim_prize:
  77. 				claimants = append(claimants, pid)
  78. 			}
  79. 		}
  80. 	}
  82. 	fmt.Println(claimants)
  83. }

编辑：
确切的问题是生产者需要将数字发送给每个消费者。当消费者接收到其令牌中的所有数字时，它可以声明获奖。根据 @OneOfOne 的说法，我对程序进行了一些更改。更改的内容是现在为每个消费者都有一个单独的通道，并在它声明获奖后关闭它。以下是新程序，它仍然发生死锁。

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"math/rand"
  6. )
  8. func contains(s []int, e int) bool {
  9. 	for _, a := range s {
  10. 		if a == e {
  11. 			return true
  12. 		}
  13. 	}
  14. 	return false
  15. }
  17. func Person(called_number chan int, claim_prize chan int, received chan bool, coupon []int, person_id int) {
  18. 	numFound := 0
  19. 	for current_number := range called_number {
  20. 		if contains(coupon, current_number) {
  21. 			numFound++
  22. 		}
  23. 		if numFound == len(coupon) {
  24. 			fmt.Println(person_id)
  25. 			claim_prize <- person_id
  26. 		} else {
  27. 			received <- true
  28. 		}
  29. 	}
  30. }
  32. func main() {
  33. 	var (
  34. 		called_number1 = make(chan int, 1)
  35. 		called_number2 = make(chan int, 1)
  36. 		called_number3 = make(chan int, 1)
  37. 		claim_prize    = make(chan int, 1)
  38. 		received       = make(chan bool, 1)
  39. 	)
  41. 	tokens := make([][]int, 3)
  42. 	for i := 0; i < 3; i++ {
  43. 		tokens[i] = make([]int, 12)
  44. 		for j := 0; j < 12; j++ {
  45. 			num := rand.Intn(100) + 1
  46. 			found := contains(tokens[i], num)
  47. 			for found {
  48. 				num = rand.Intn(100) + 1
  49. 				found = contains(tokens[i], num)
  50. 			}
  51. 			tokens[i][j] = num
  52. 		}
  53. 	}
  55. 	go Person(called_number1, claim_prize, received, tokens[0], 0)
  56. 	go Person(called_number2, claim_prize, received, tokens[1], 1)
  57. 	go Person(called_number3, claim_prize, received, tokens[2], 2)
  59. 	claimants := make([]int, 0)
  60. 	prev_called := make(map[int]bool)
  61. 	for i := 0; i < 100; i++ {
  62. 		if len(claimants) == 3 {
  63. 			break
  64. 		}
  65. 		num := rand.Intn(100) + 1
  66. 		_, ok := prev_called[num]
  67. 		for ok {
  68. 			num = rand.Intn(100) + 1
  69. 			_, ok = prev_called[num]
  70. 		}
  71. 		prev_called[num] = true
  72. 		if !contains(claimants, 0) {
  73. 			called_number1 <- num
  74. 		}
  75. 		if !contains(claimants, 1) {
  76. 			called_number2 <- num
  77. 		}
  78. 		if !contains(claimants, 2) {
  79. 			called_number3 <- num
  80. 		}
  81. 		for j := 0; j < 3; j++ {
  82. 			select {
  83. 			case _ = <-received:
  84. 				continue
  85. 			case pid := <-claim_prize:
  86. 				if pid == 0 { close(called_number1) }
  87. 				if pid == 1 { close(called_number2) }
  88. 				if pid == 2 { close(called_number3) }
  89. 				claimants = append(claimants, pid)
  90. 			}
  91. 		}
  92. 	}
  93. 	fmt.Println(claimants)
  94. }
  96. 编辑2：这仍然发生死锁，因为即使 goroutine 完成了，我也没有减少等待的通道数量。我进行了修改，现在一切正常运行。
  98. <details>
  99. <summary>英文:</summary>
  101. I am trying to implement a housie game where a goroutine produces numbers, 3 other goroutines check if these are in their tokens and inform the producer if all their numbers were produced. I have implemented it in golang in the following way. This results in a deadlock. Any idea why this is happening? This is a &quot;homework problem&quot;, I am just implementing it in go to learn go better. 
  103.     package main
  104.     
  105.     import (
  106.     	&quot;fmt&quot;
  107.     	&quot;math/rand&quot;
  108.     )
  109.     
  110.     type PersonID int
  111.     
  112.     func contains(s []int, e int) bool {
  113.     	for _, a := range s {
  114.     		if a == e {
  115.     			return true
  116.     		}
  117.     	}
  118.     	return false
  119.     }
  120.     
  121.     func Person(called_number chan int, claim_prize chan PersonID, received chan bool, coupon []int, person_id PersonID) {
  122.     	numFound := 0
  123.     	for i := 0; i &lt; len(coupon); i++ {
  124.     		current_number := &lt;-called_number
  125.     		found := contains(coupon, current_number)
  126.     		if found {
  127.     			numFound++
  128.     		}
  129.     		if numFound == len(coupon) {
  130.     			claim_prize &lt;- person_id
  131.     		} else {
  132.     			received &lt;- true
  133.     		}
  134.     	}
  135.     }
  136.     
  137.     func main() {
  138.     	var called_number chan int
  139.     	var claim_prize chan PersonID
  140.     	var received chan bool
  141.     
  142.     	tokens := make([][]int, 3)
  143.     	for i := 0; i &lt; 3; i++ {
  144.     		tokens[i] = make([]int, 12)
  145.     		for j := 0; j &lt; 12; j++ {
  146.     			num := rand.Intn(100) + 1
  147.     			found := contains(tokens[i], num)
  148.     			for found {
  149.     				num = rand.Intn(100) + 1
  150.     				found = contains(tokens[i], num)
  151.     			}
  152.     			tokens[i][j] = num
  153.     		}
  154.     	}
  155.     
  156.     	go Person(called_number, claim_prize, received, tokens[0], 0)
  157.     	go Person(called_number, claim_prize, received, tokens[1], 1)
  158.     	go Person(called_number, claim_prize, received, tokens[2], 2)
  159.     
  160.     	claimants := make([]PersonID, 0)
  161.     	prev_called := make(map[int]bool)
  162.     	for i := 0; i &lt; 100; i++ {
  163.     		if len(claimants) == 3 {
  164.     			break
  165.     		}
  166.     		num := rand.Intn(100) + 1
  167.     		_, ok := prev_called[num]
  168.     		for ok {
  169.     			num = rand.Intn(100) + 1
  170.     			_, ok = prev_called[num]
  171.     		}
  172.     		prev_called[num] = true
  173.     		called_number &lt;- num
  174.     		for j := 0; j &lt; 3; j++ {
  175.     			select {
  176.     			case _ = &lt;-received:
  177.     				continue
  178.     			case pid := &lt;-claim_prize:
  179.     				claimants = append(claimants, pid)
  180.     			}
  181.     		}
  182.     	}
  183.     
  184.     	fmt.Println(claimants)
  185.     }
  187. EDIT:
  188. The exact problem is that that the producer needs to send the number to each of the consumers. When a consumer receives all the numbers in it&#39;s token, it can claim the prize. Based on what @OneOfOne said, I have made some changes to the program. The changes are that now there is a separate channels for each of the consumers and I am closing it after it claims a prize. Below is the new program, it still deadlocks. 
  190.     package main
  191.     
  192.     import (
  193.     	&quot;fmt&quot;
  194.     	&quot;math/rand&quot;
  195.     )
  196.     
  197.     func contains(s []int, e int) bool {
  198.     	for _, a := range s {
  199.     		if a == e {
  200.     			return true
  201.     		}
  202.     	}
  203.     	return false
  204.     }
  205.     
  206.     func Person(called_number chan int, claim_prize chan int, received chan bool, coupon []int, person_id int) {
  207.     	numFound := 0
  208.     	for current_number := range called_number {
  209.     		if contains(coupon, current_number) {
  210.     			numFound++
  211.     		}
  212.     		if numFound == len(coupon) {
  213.     			fmt.Println(person_id)
  214.     			claim_prize &lt;- person_id
  215.     		} else {
  216.     			received &lt;- true
  217.     		}
  218.     	}
  219.     }
  220.     
  221.     func main() {
  222.     	var (
  223.     		called_number1 = make(chan int, 1)
  224.     		called_number2 = make(chan int, 1)
  225.     		called_number3 = make(chan int, 1)
  226.     		claim_prize    = make(chan int, 1)
  227.     		received       = make(chan bool, 1)
  228.     	)
  229.     
  230.     	tokens := make([][]int, 3)
  231.     	for i := 0; i &lt; 3; i++ {
  232.     		tokens[i] = make([]int, 12)
  233.     		for j := 0; j &lt; 12; j++ {
  234.     			num := rand.Intn(100) + 1
  235.     			found := contains(tokens[i], num)
  236.     			for found {
  237.     				num = rand.Intn(100) + 1
  238.     				found = contains(tokens[i], num)
  239.     			}
  240.     			tokens[i][j] = num
  241.     		}
  242.     	}
  243.     
  244.     	go Person(called_number1, claim_prize, received, tokens[0], 0)
  245.     	go Person(called_number2, claim_prize, received, tokens[1], 1)
  246.     	go Person(called_number3, claim_prize, received, tokens[2], 2)
  247.     
  248.     	claimants := make([]int, 0)
  249.     	prev_called := make(map[int]bool)
  250.     	for i := 0; i &lt; 100; i++ {
  251.     		if len(claimants) == 3 {
  252.     			break
  253.     		}
  254.     		num := rand.Intn(100) + 1
  255.     		_, ok := prev_called[num]
  256.     		for ok {
  257.     			num = rand.Intn(100) + 1
  258.     			_, ok = prev_called[num]
  259.     		}
  260.     		prev_called[num] = true
  261.     		if !contains(claimants, 0) {
  262.     			called_number1 &lt;- num
  263.     		}
  264.     		if !contains(claimants, 1) {
  265.     			called_number2 &lt;- num
  266.     		}
  267.     		if !contains(claimants, 2) {
  268.     			called_number3 &lt;- num
  269.     		}
  270.     		for j := 0; j &lt; 3; j++ {
  271.     			select {
  272.     			case _ = &lt;-received:
  273.     				continue
  274.     			case pid := &lt;-claim_prize:
  275.     				if pid == 0 { close(called_number1) }
  276.     				if pid == 1 { close(called_number2) }
  277.     				if pid == 2 { close(called_number3) }
  278.     				claimants = append(claimants, pid)
  279.     			}
  280.     		}
  281.     	}
  282.     	fmt.Println(claimants)
  283.     }
  285. EDIT2: This still deadlocked because I was not reducing the number of channels to wait for even after the goroutines were completed. Did that and everything works. 
  287. </details>
  290. # 答案1
  291. **得分**: 2
  293. 几个问题：
  295. 1. 你正在使用一个空通道，所以它会永远阻塞，但出于某种原因它没有引发错误。
  297. 2. 另外，你的第二个内部循环会无限期地阻塞，因为它在等待读取，但没有发送任何内容。
  299. 3. 在 `Person` 的循环结束后，`called_number <- num` 会永远阻塞。
  301. //编辑
  302. 部分可工作的代码：http://play.golang.org/p/3At5nuJTuk
  304. 但是逻辑有问题，你需要重新考虑一下。
  306. <details>
  307. <summary>英文:</summary>
  309. Few problems:
  311. 1. You&#39;re using a nil channel, so it just blocks forever, for some reason it&#39;s not panicing.
  313. 2. Also, your second inner loop will block indefinitely because it&#39;s waiting to read but nothing is being sent.
  315. 3. After your `Person`&#39;s loop ends, `called_number &lt;- num` will block forever.
  318. //edit
  319. Kinda-working-code : http://play.golang.org/p/3At5nuJTuk
  321. But the logic is flawed, you will have to rethink it.
  323. </details>

huangapple
  • 本文由 发表于 2015年4月11日 09:52:36
  • 转载请务必保留本文链接：https://go.coder-hub.com/29573148.html
  • channel
  • deadlock
  • go
  • goroutine
匿名

发表评论

匿名网友

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

确定