Golang Goroutine泄漏

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

Golang Goroutine leak

问题

这段代码是关于Go语言并发的一个解决方案。在Same()函数中，有一个注释说它会泄漏goroutine，这是什么意思呢？它还提到了一个修复这个问题的第二个文件。

在第一个文件中，Same()函数使用了两个goroutine来遍历两个树，并将它们的值发送到两个通道中。然后，通过从通道中接收值并比较它们，判断两个树是否包含相同的值。但是，如果两个树的结构不同，其中一个树的遍历会先结束，而另一个树的goroutine仍然在运行。这就是所谓的goroutine泄漏，因为没有正确地关闭goroutine。

为了解决这个问题，第二个文件中的代码对Walk()函数进行了修改。在walkImpl()函数中，使用了一个额外的quit通道来通知goroutine停止运行。当遍历到树的某个节点时，通过select语句同时监听ch和quit通道，如果quit通道有值可接收，就立即返回，停止继续遍历。这样，即使两个树的结构不同，也能正确地停止遍历并关闭所有的goroutine。

希望这能帮到你！如果还有其他问题，请随时提问。

英文: 
  1. // Copyright 2012 The Go Authors.  All rights reserved.
  2. // Use of this source code is governed by a BSD-style
  3. // license that can be found in the LICENSE file.
  5. // +build ignore
  7. package main
  9. import (
  10. 	"fmt"
  12. 	"code.google.com/p/go-tour/tree"
  13. )
  15. func walkImpl(t *tree.Tree, ch chan int) {
  16. 	if t == nil {
  17. 		return
  18. 	}
  19. 	walkImpl(t.Left, ch)
  20. 	ch <- t.Value
  21. 	walkImpl(t.Right, ch)
  22. }
  24. // Walk walks the tree t sending all values
  25. // from the tree to the channel ch.
  26. func Walk(t *tree.Tree, ch chan int) {
  27. 	walkImpl(t, ch)
  28. 	// Need to close the channel here
  29. 	close(ch)
  30. }
  32. // Same determines whether the trees
  33. // t1 and t2 contain the same values.
  34. // NOTE: The implementation leaks goroutines when trees are different.
  35. // See binarytrees_quit.go for a better solution.
  36. func Same(t1, t2 *tree.Tree) bool {
  37. 	w1, w2 := make(chan int), make(chan int)
  39. 	go Walk(t1, w1)
  40. 	go Walk(t2, w2)
  42. 	for {
  43. 		v1, ok1 := <-w1
  44. 		v2, ok2 := <-w2
  45. 		if !ok1 || !ok2 {
  46. 			return ok1 == ok2
  47. 		}
  48. 		if v1 != v2 {
  49. 			return false
  50. 		}
  51. 	}
  52. }
  54. func main() {
  55. 	fmt.Print("tree.New(1) == tree.New(1): ")
  56. 	if Same(tree.New(1), tree.New(1)) {
  57. 		fmt.Println("PASSED")
  58. 	} else {
  59. 		fmt.Println("FAILED")
  60. 	}
  62. 	fmt.Print("tree.New(1) != tree.New(2): ")
  63. 	if !Same(tree.New(1), tree.New(2)) {
  64. 		fmt.Println("PASSED")
  65. 	} else {
  66. 		fmt.Println("FAILED")
  67. 	}
  68. }

In this code, a solution for http://tour.golang.org/concurrency/8

Why is there a comment on Same() func Same(t1, t2 *tree.Tree) bool saying that it leaks goroutines? How so? It also mentions a second file that fixes this:

  1. // Copyright 2015 The Go Authors.  All rights reserved.
  2. // Use of this source code is governed by a BSD-style
  3. // license that can be found in the LICENSE file.
  5. // +build ignore
  7. package main
  9. import (
  10. 	"fmt"
  12. 	"code.google.com/p/go-tour/tree"
  13. )
  15. func walkImpl(t *tree.Tree, ch, quit chan int) {
  16. 	if t == nil {
  17. 		return
  18. 	}
  19. 	walkImpl(t.Left, ch, quit)
  20. 	select {
  21. 	case ch <- t.Value:
  22. 		// Value successfully sent.
  23. 	case <-quit:
  24. 		return
  25. 	}
  26. 	walkImpl(t.Right, ch, quit)
  27. }
  29. // Walk walks the tree t sending all values
  30. // from the tree to the channel ch.
  31. func Walk(t *tree.Tree, ch, quit chan int) {
  32. 	walkImpl(t, ch, quit)
  33. 	close(ch)
  34. }
  36. // Same determines whether the trees
  37. // t1 and t2 contain the same values.
  38. func Same(t1, t2 *tree.Tree) bool {
  39. 	w1, w2 := make(chan int), make(chan int)
  40. 	quit := make(chan int)
  41. 	defer close(quit)
  43. 	go Walk(t1, w1, quit)
  44. 	go Walk(t2, w2, quit)
  46. 	for {
  47. 		v1, ok1 := <-w1
  48. 		v2, ok2 := <-w2
  49. 		if !ok1 || !ok2 {
  50. 			return ok1 == ok2
  51. 		}
  52. 		if v1 != v2 {
  53. 			return false
  54. 		}
  55. 	}
  56. }
  58. func main() {
  59. 	fmt.Print("tree.New(1) == tree.New(1): ")
  60. 	if Same(tree.New(1), tree.New(1)) {
  61. 		fmt.Println("PASSED")
  62. 	} else {
  63. 		fmt.Println("FAILED")
  64. 	}
  66. 	fmt.Print("tree.New(1) != tree.New(2): ")
  67. 	if !Same(tree.New(1), tree.New(2)) {
  68. 		fmt.Println("PASSED")
  69. 	} else {
  70. 		fmt.Println("FAILED")
  71. 	}
  72. }

How does it accomplish that? Where was this leak? (to test the code you will have to run it on http://tour.golang.org/concurrency/8). Very confused and would appreciate some help, thanks!

答案1

得分: 2

程序在检测到差异时停止接收通道上的数据。

walk协程会一直运行，直到它们被阻塞在发送数据到通道上。它们永远不会退出。这就是泄漏的原因。

英文:

The program stops receiving on the channels when a difference is detected.

The walk goroutines run until they block sending to the channels. They never exit. This is the leak.

答案2

得分: 0

第二种解决方案通过使用退出通道来处理泄漏。当退出通道关闭时（在Same（）函数中），选择语句的第2个case成功（在walkImpl函数中的case <-quit），并且函数返回。因此，在程序退出后，walkImpl函数中没有阻塞。

英文:

The second solution handles the leak by using the quit channel. When the quit channel is closed (in Same() function), the case 2 of select statement succeeds(case <-quit in walkImpl function) and the function returns. Hence there is no block in the walkImpl function after the program exits.

huangapple
  • 本文由 发表于 2015年3月22日 10:35:52
  • 转载请务必保留本文链接：https://go.coder-hub.com/29190333.html
  • go
  • goroutine
  • memory-leaks
匿名

发表评论

匿名网友

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

确定