Golang中的select语句可以同时等待互斥锁和通道。

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

Golang select wait on both a mutex lock and a channel

问题

在Go语言中，可以使用select语句同时等待多个通道。例如：

  1. package main
  3. import "fmt"
  5. func fibonacci(c, quit chan int) {
  6. 	x, y := 0, 1
  7. 	for {
  8. 		select {
  9. 		case c <- x:
  10. 			x, y = y, x+y
  11. 		case <-quit:
  12. 			fmt.Println("quit")
  13. 			return
  14. 		}
  15. 	}
  16. }
  18. func main() {
  19. 	c := make(chan int)
  20. 	quit := make(chan int)
  21. 	go func() {
  22. 		for i := 0; i < 10; i++ {
  23. 			fmt.Println(<-c)
  24. 		}
  25. 		quit <- 0
  26. 	}()
  27. 	fibonacci(c, quit)
  28. }

（摘自https://go.dev/tour/concurrency/5）

是否有一种机制可以类似地使用互斥锁（mutex lock），在等待通道或互斥锁可用时进行等待？类似这样：

  1. package main
  3. import "fmt"
  4. import "sync"
  6. func fibonacci(c chan int, mu sync.Mutex) {
  7. 	x, y := 0, 1
  8. 	for {
  9. 		select {
  10. 		case c <- x:
  11. 			x, y = y, x+y
  12. 		case mu.Lock():
  13. 			fmt.Println("locked")
  14. 			return
  15. 		}
  16. 	}
  17. }
  19. func main() {
  20. 	c := make(chan int)
  21. 	var mu sync.Mutex
  22. 	go func() {
  23. 		for i := 0; i < 10; i++ {
  24. 			fmt.Println(<-c)
  25. 		}
  26. 		mu.Lock()
  27. 	}()
  28. 	fibonacci(c, mu)
  29. }

实际的使用场景是，我将一个context传递给一个函数，该函数可能会在互斥锁上等待一段时间，我希望能够通过上下文中止等待。

英文:

In golang it is possible to use a select statement to wait on multiple channels at a time. For example,

  1. package main
  3. import &quot;fmt&quot;
  5. func fibonacci(c, quit chan int) {
  6. 	x, y := 0, 1
  7. 	for {
  8. 		select {
  9. 		case c &lt;- x:
  10. 			x, y = y, x+y
  11. 		case &lt;-quit:
  12. 			fmt.Println(&quot;quit&quot;)
  13. 			return
  14. 		}
  15. 	}
  16. }
  18. func main() {
  19. 	c := make(chan int)
  20. 	quit := make(chan int)
  21. 	go func() {
  22. 		for i := 0; i &lt; 10; i++ {
  23. 			fmt.Println(&lt;-c)
  24. 		}
  25. 		quit &lt;- 0
  26. 	}()
  27. 	fibonacci(c, quit)
  28. }

(Lifted from https://go.dev/tour/concurrency/5)

Is there any mechanism to do something similar with a mutex lock, where you wait for either a channel or for a mutex lock to become available? Something like:

  1. package main
  3. import &quot;fmt&quot;
  4. import &quot;sync&quot;
  6. func fibonacci(c chan int, mu sync.Mutex) {
  7. 	x, y := 0, 1
  8. 	for {
  9. 		select {
  10. 		case c &lt;- x:
  11. 			x, y = y, x+y
  12. 		case mu.Lock():
  13. 			fmt.Println(&quot;locked&quot;)
  14. 			return
  15. 		}
  16. 	}
  17. }
  19. func main() {
  20. 	c := make(chan int)
  21. 	var mu sync.Mutex
  22. 	go func() {
  23. 		for i := 0; i &lt; 10; i++ {
  24. 			fmt.Println(&lt;-c)
  25. 		}
  26. 		mu.Lock()
  27. 	}()
  28. 	fibonacci(c, quit, mu)
  29. }

The actual use scenario is that I'm passing in a context to a function that might be waiting on a mutex lock for a while, and I'd like to be able to abort the wait through the context.

答案1

得分: 2

有没有一种机制可以类似于互斥锁，等待通道或互斥锁可用的情况？

没有。

你必须重新设计，例如通过用基于通道的信号量替换互斥锁。

英文:

> Is there any mechanism to do something similar with a mutex lock, where you wait for either a channel or for a mutex lock to become available?

No.

You must redesign, e.g. by replacing the mutex with a channel based semaphore.

huangapple
  • 本文由 发表于 2022年10月1日 14:29:07
  • 转载请务必保留本文链接：https://go.coder-hub.com/73916277.html
  • concurrency
  • go
  • mutex
匿名

发表评论

匿名网友

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

确定