golang 2 go routines if one terminates terminate the other one

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

golang 2 go routines if one terminates terminate the other one

问题

所以我正在使用gorilla的websocket库，我正在构建一个websocket服务器。当我接收到一个连接时，我创建两个goroutine，一个用于从客户端读取传入的消息，另一个用于监听传入的消息并将其发送到客户端。

  1. func (p *Player) EventLoop() {
  2.     l4g.Info("Starting player %s event loop", p)
  3.     go p.readFromSocket()
  4.     go p.writeToSocket()
  6.     //blocks until we receive an interrupt from the read channel
  7.     <-p.closeEventChan
  8.     p.cleanup() //nothing else to do so lets cleanup
  9. }
  11. func (p *Player) writeToSocket() {
  12.     for m := range p.writeChan {
  13.         if p.conn == nil {
  14.             break
  15.         }
  17.         if reflect.DeepEqual(network.Packet{}, m) == true {
  18.             break
  19.         }
  21.         if err := p.conn.WriteJSON(m); err != nil {
  22.             break
  23.         }
  24.     }
  25.     p.closeEventChan <- true
  26. }
  28. func (p *Player) readFromSocket() {
  29.     for {
  30.         if p.conn == nil {
  31.             break
  32.         }
  34.         m := network.Packet{}
  36.         if err := p.conn.ReadJSON(m); err != nil {
  37.             break
  38.         }
  39.     }
  40.     p.closeEventChan <- true
  41. }
  43. func (p *Player) Cleanup() {
  45.     //make sure the channels get a close message which will break us out of the go routines
  46.     close(p.writeChan)
  47.     close(p.closeEventChan)
  49.     //only close the connection if we have a connection
  50.     if p.conn != nil {
  51.         p.conn.Close()
  52.         p.conn = nil
  53.     }
  54. }

我的问题是，如果我们离开readFromSocket()循环，Cleanup()会被调用，但我们永远不会离开writeToSocket()循环！这个问题可以在这个Go Playground中更简单地演示：https://play.golang.org/p/49bh7bbbG-

我们如何修复这个问题，以便如果我们离开writeToSocket()循环，我们也离开readFromSocket()循环，反之亦然？

我曾经以为这样做会起作用，因为如果你在一个通道上调用close(p.writeChan)，通道接受的默认值将被发送。

英文:

so I am using gorillas websocket library and I'm building a websocket server when I receive a connection I create 2 go routines one to read incoming messages from the client and another 1 to listen for in coming messages sent to the channel and then send them to the client.

  1. func (p *Player) EventLoop() {
  2.     l4g.Info(&quot;Starting player %s event loop&quot;, p)
  3.     go p.readFromSocket()
  4.     go p.writeToSocket()
  6.     //blocks until we receive an interrupt from the read channel
  7.     &lt;-p.closeEventChan
  8.     p.cleanup() //nothing else to do so lets cleanup
  9. }
  11. func (p *Player) writeToSocket() {
  12.     for m := range p.writeChan {
  13.         if p.conn == nil {
  14.             break
  15.         }
  17.         if reflect.DeepEqual(network.Packet{}, m) == true {
  18.             break
  19.         }
  21.         if err := p.conn.WriteJSON(m); err != nil {
  22.             break
  23.         }
  24.     }
  25.     p.closeEventChan &lt;- true
  26. }
  28. func (p *Player) readFromSocket() {
  29.     for {
  30.         if p.conn == nil {
  31.             break
  32.         }
  34.         m := network.Packet{}
  36.         if err := p.conn.ReadJSON(m); err != nil {
  37.             break
  38.         }
  39.     }
  40.     p.closeEventChan &lt;- true
  41. }
  43. func (p *Player) Cleanup() {
  45.     //make sure the channels get a close message which will break us out of the go routines
  46.     close(p.writeChan)
  47.     close(p.closeEventChan)
  49.     //only close the connection if we have a connection
  50.     if p.conn != nil {
  51.         p.conn.Close()
  52.         p.conn = nil
  53.     }
  54. }

my problem is if we leave the readFromSocket() loop Cleanup() is called however we never leave the writeToSocket() loop ! this problem can be simpler demonstrated in this go playground https://play.golang.org/p/49bh7bbbG-

how can we fix this so if we leave the writeToSocket() loop we also leave the readFromSocket() loop and vice vesa?

I was under the impression that this would work as if you call close on a channel (close(p.writeChan)) the default value that the channel accepts will be sent

答案1

得分: 3

你通常可以使用共享的退出通道和一些计数来实现这一点。

  1. func (p *Player) writeToSocket(quit <-chan struct{}) {
  2.     defer func() {
  3.         p.closeEventChan <- true
  4.     }()
  5.     for {
  6.         select {
  7.         case <-quit:
  8.             return
  9.         case m := <-p.writeChan:
  10.             // 做一些操作
  11.         // writeChan关闭但quit没有关闭的情况
  12.         default:
  13.             return
  14.         }
  15.     }
  16. }
  18. func (p *Player) readFromSocket(quit <-chan struct{}) {
  19.     defer func() {
  20.         p.closeEventChan <- true
  21.     }()
  22.     for {
  23.         select {
  24.         case <-quit:
  25.             return
  26.         default:
  27.             // 做一些操作
  28.         }
  29.     }
  30. }
  32. func (p *Player) EventLoop() {
  33.     l4g.Info("Starting player %s event loop", p)
  34.     quit := make(chan struct{})
  35.     go p.readFromSocket(quit)
  36.     go p.writeToSocket(quit)
  38.     // 阻塞直到从读通道接收到中断信号
  39.     <-p.closeEventChan
  40.     close(quit)
  41.     // 这里是多余的，但在不同的情况下，你可以使用NumWorkers变量循环遍历剩余的工作线程数
  42.     for i := 0; i < 1; i++ {
  43.         <-p.closeEventChan
  44.     }
  45.     p.cleanup() // 没有其他事情要做，所以进行清理
  46. }

这里的思路是：

  1. 所有工作线程在返回之前通过一个通道向中央循环发送关闭信号。
  2. 所有工作线程在收到退出消息（通过关闭通道）后返回。
  3. 中央循环在第一个工作线程退出后关闭退出通道，然后等待其他工作线程退出。
英文:

You can usually do this with a shared quit channel, and some counting.

  1. func (p *Player) writeToSocket(quit &lt;-chan struct{})
  2.     defer func() {
  3.         p.closeEventChan &lt;- true
  4.     }()
  5.     for {
  6.         select {
  7.         case &lt;-quit:
  8.             return
  9.         case m := &lt;-p.writeChan:
  10.             // Do stuff
  11.         // Case where writeChan is closed, but quit isn&#39;t
  12.         default:
  13.             return
  14.         }
  15.     }
  16. }
  19. func (p *Player) readFromSocket(quit &lt;-chan struct{})
  20.     defer func() {
  21.         p.closeEventChan &lt;- true
  22.     }()
  23.     for {
  24.         select {
  25.         case &lt;-quit:
  26.             return
  27.         default:
  28.             // Do stuff
  29.         }
  30.     }
  31. }
  33. func (p *Player) EventLoop() {
  34.     l4g.Info(&quot;Starting player %s event loop&quot;, p)
  35.     quit := make(chan struct{})
  36.     go p.readFromSocket(quit)
  37.     go p.writeToSocket(quit)
  39.     //blocks until we receive an interrupt from the read channel
  40.     &lt;-p.closeEventChan
  41.     close(quit)
  42.     // This is superfluous here, but in a different case
  43.     // you loop over the remaining number of workers using a NumWorkers variable
  44.     for i := 0; i &lt; 1; i++ {
  45.         &lt;-p.closeEventChan
  46.     }
  47.     p.cleanup() //nothing else to do so lets cleanup
  48. }

The idea here is that:

  1. All workers notify the central routine upon close via a channel before returning.
  2. All workers return upon a quit message being broadcast (via close).
  3. The central loop closes the quit channel after the first worker exits, then waits for the rest to exit.

huangapple
  • 本文由 发表于 2014年12月27日 04:19:52
  • 转载请务必保留本文链接：https://go.coder-hub.com/27661569.html
  • channel
  • go
  • goroutine
匿名

发表评论

匿名网友

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

确定