如何在没有竞争的情况下延长计时器的持续时间？

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

How to extend the ticker duration without a race?

问题

我正在尝试实现一个保持连接的机制。问题在于，我不知道如何在没有竞争的情况下替换保持连接的计时器（conn.keepAlive），因为keepAlive()方法总是从计时器中读取。

//为了简洁起见，未处理错误
const interval = 10 * time.Second

type conn struct {
keepAlive time.Ticker
conn net.Conn
mux sync.Mutex
}

// replace替换底层连接
func (cn conn) replace(newcn net.Conn) {
cn.mux.Lock()
cn.conn = newcn
// 重置计时器
cn.keepAlive.Stop
cn.keepAlive = time.NewTicker(interval)
cn.mux.Unlock()
}

func (cn conn) keepAlive() {
for {
<-cn.keepAlive.C
cn.mux.Lock()
cn.conn.Write([]byte("ping"))
var msg []byte
cn.conn.Read(msg)
if string(msg) != "pong" {
// 做一些坏事
}
cn.keepAlive = time.NewTicker(interval)
cn.mux.Unlock()
}
}

英文:

I'm trying to implement a keepAlive mechanism. The issue is that I don't know how to replace the keep alive ticker ( conn.keepAlive) without a race because keepAlive() method always reads from the ticker.

  1. //errors not handled for brevity
  2. const interval = 10 * time.Second
  4. type conn struct {
  5. 	keepAlive time.Ticker
  6. 	conn      net.Conn
  7. 	mux       sync.Mutex
  8. }
  10. // replace replaces the underlying connection
  11. func (cn conn) replace(newcn net.Conn) {
  12. 	cn.mux.Lock()
  13. 	cn.conn = newcn
  14. 	// reset the ticker
  15. 	cn.keepAlive.Stop
  16. 	cn.keepAlive = time.NewTicker(interval)
  17. 	cn.mux.Unlock()
  18. }
  20. func (cn conn) keepAlive() {
  21. 	for {
  22. 		&lt;-cn.keepAlive.C
  23. 		cn.mux.Lock()
  24. 		cn.conn.Write([]byte(&quot;ping&quot;))
  25. 		var msg []byte
  26. 		cn.conn.Read(msg)
  27. 		if string(msg) != &quot;pong&quot; {
  28. 			// do some mean stuff
  29. 		}
  30. 		cn.keepAlive = time.NewTicker(interval)
  31. 		cn.mux.Unlock()
  32. 	}
  33. }

答案1

得分: 0

一种更简洁的实现方式是使用通道作为同步机制，而不是互斥锁：

  1. type conn struct {
  2.     sync.Mutex
  3.     conn        net.Conn
  4.     replaceConn chan net.Conn
  5. }
  7. // replace replaces the underlying connection
  8. func (cn *conn) replace(newcn net.Conn) {
  9.     cn.replaceConn <- newcn
  10. }
  12. func (cn *conn) keepAlive() {
  13.     t := time.NewTicker(interval)
  14.     msg := make([]byte, 10)
  16.     for {
  17.         select {
  18.         case <-t.C:
  19.         case newConn := <-cn.replaceConn:
  20.             cn.Lock()
  21.             cn.conn = newConn
  22.             cn.Unlock()
  23.             continue
  24.         }
  26.         cn.Lock()
  27.         _ = msg
  28.         // do keepalive
  29.         cn.Unlock()
  30.     }
  31. }

以上是代码的翻译结果。

英文:

One way to implement this much more succinctly, is by using a channel as the synchronization mechanism, instead of the mutex:

  1. type conn struct {
  2. 	sync.Mutex
  3. 	conn        net.Conn
  4. 	replaceConn chan net.Conn
  5. }
  7. // replace replaces the underlying connection
  8. func (cn *conn) replace(newcn net.Conn) {
  9. 	cn.replaceConn &lt;- newcn
  10. }
  12. func (cn *conn) keepAlive() {
  13. 	t := time.NewTicker(interval)
  14. 	msg := make([]byte, 10)
  16. 	for {
  17. 		select {
  18. 		case &lt;-t.C:
  19. 		case newConn := &lt;-cn.replaceConn:
  20. 			cn.Lock()
  21. 			cn.conn = newConn
  22. 			cn.Unlock()
  23. 			continue
  24. 		}
  26. 		cn.Lock()
  27. 		_ = msg
  28. 		// do keepalive
  29. 		cn.Unlock()
  30. 	}
  31. }

答案2

得分: -2

我最终得到了下面的代码。我对它的外观不太满意，但它是有效的。基本上，我在一个通道中包装了mux，这样我就可以在其上进行选择。

  1. const interval = 10 * time.Second
  3. type conn struct {
  4. 	keepAlive time.Ticker
  5. 	conn      *net.Conn
  6. 	mux       sync.Mutex
  7. }
  9. // replace replaces the underlying connection
  10. func (cn conn) replace(newcn *net.Conn) {
  11. 	cn.mux.Lock()
  12. 	cn.conn = newcn
  13. 	// reset the ticker
  14. 	cn.keepAlive.Stop()
  15. 	cn.keepAlive = time.NewTicker(interval)
  16. 	cn.mux.Unlock()
  17. }
  19. func (cn conn) keepAlive() {
  20. 	lockerFn := func() <-chan struct{} {
  21. 		cn.mux.Lock()
  22. 		ch := make(chan struct{})
  23. 		go func() {
  24. 			ch <- struct{}{}
  25. 		}()
  26. 		return ch
  27. 	}
  28. 	for {
  29. 		locker := lockerFn()
  30. 		select {
  31. 		case <-cn.keepAlive.C:
  32. 			// unlock the locker otherwise we
  33. 			// get stuck
  34. 			go func() {
  35. 				<-locker
  36. 				cn.mux.Unlock()
  37. 			}()
  38. 		case <-locker:
  39. 			cn.conn.Write([]byte("ping"))
  40. 			var msg []byte
  41. 			cn.conn.Read(msg)
  42. 			cn.keepAlive = time.NewTicker(interval)
  43. 			cn.mux.Unlock()
  44. 		}
  45. 	}
  46. }

以上是翻译好的代码部分。

英文:

I ended up with the code below. I'm not very happy how it looks like but it works. Basically I wrapped the mux in a channel so that I can do a select on it.

  1. const interval = 10 * time.Second
  3. type conn struct {
  4. 	keepAlive time.Ticker
  5. 	conn      *net.Conn
  6. 	mux       sync.Mutex
  7. }
  9. // replace replaces the underlying connection
  10. func (cn conn) replace(newcn *net.Conn) {
  11. 	cn.mux.Lock()
  12. 	cn.conn = newcn
  13. 	// reset the ticker
  14. 	cn.keepAlive.Stop
  15. 	cn.keepAlive = time.NewTicker(interval)
  16. 	cn.mux.Unlock()
  17. }
  19. func (cn conn) keepAlive() {
  20. 	lockerFn := func() &lt;-chan struct{} {
  21. 		cn.mux.Lock()
  22. 		ch = make(chan struct{})
  23. 		go func() {
  24. 			ch &lt;- struct{}{}
  25. 		}()
  26. 		return ch
  27. 	}
  28. 	for {
  29. 		locker := lockerFn()
  30. 		select {
  31. 		case &lt;-cn.keepAlive.C:
  32. 			// unlock the locker otherwise we
  33. 			// get stuck
  34. 			go func() {
  35. 				&lt;-locker
  36. 				cn.mux.Unlock()
  37. 			}()
  38. 		case &lt;-locker:
  39. 			cn.conn.Write([]byte(&quot;ping&quot;))
  40. 			var msg []byte
  41. 			cn.conn.Read(msg)
  42. 			cn.keepAlive = time.NewTicker(interval)
  43. 			cn.mux.Unlock()
  44. 		}
  45. 	}
  46. }

huangapple
  • 本文由 发表于 2015年8月13日 03:00:02
  • 转载请务必保留本文链接：https://go.coder-hub.com/31973345.html
  • go
  • ping
  • synchronization
匿名

发表评论

匿名网友

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

确定