不使用互斥锁

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

Going mutex-less

问题

好的，以下是代码的中文翻译：

  1. package main
  3. import (
  4. 	"fmt"
  5. )
  7. func main() {
  8. 	done := make(chan int)
  9. 	x := 0
  10. 	for i := 0; i < 10; i++ {
  11. 		go func() {
  12. 			y := next(&x)
  13. 			fmt.Println(y)
  14. 			done <- 0
  15. 		}()
  16. 	}
  17. 	for i := 0; i < 10; i++ {
  18. 		<-done
  19. 	}
  20. 	fmt.Println(x)
  22. }
  24. var mutex = make(chan int, 1)
  26. func next(p *int) int {
  27. 	mutex <- 0
  28. 	// 临界区开始
  29. 	x := *p
  30. 	*p++
  31. 	// 临界区结束
  32. 	<-mutex
  33. 	return x
  35. }

假设不能同时有两个goroutine进入临界区，否则会发生问题。

我第一个猜测是使用一个单独的goroutine来处理状态，但我无法找到一种匹配输入/输出的方法。

英文:

Alright, Go "experts". How would you write this code in idiomatic Go, aka without a mutex in next?

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. )
  7. func main() {
  8. 	done := make(chan int)
  9. 	x := 0
  10. 	for i := 0; i &lt; 10; i++ {
  11. 		go func() {
  12. 			y := next(&amp;x)
  13. 			fmt.Println(y)
  14. 			done &lt;- 0
  15. 		}()
  16. 	}
  17. 	for i := 0; i &lt; 10; i++ {
  18. 		&lt;-done
  19. 	}
  20. 	fmt.Println(x)
  22. }
  24. var mutex = make(chan int, 1)
  26. func next(p *int) int {
  27. 	mutex &lt;- 0
  28.     // critical section BEGIN
  29. 	x := *p
  30. 	*p++
  31.     // critical section END
  32. 	&lt;-mutex
  33. 	return x
  35. }

Assume you can't have two goroutines in the critical section at the same time, or else bad things will happen.

My first guess is to have a separate goroutine to handle the state, but I can't figure out a way to match up inputs / outputs.

答案1

得分: 3

你可以使用实际的sync.Mutex：

  1. var mutex sync.Mutex
  3. func next(p *int) int {
  4.     mutex.Lock()
  5.     defer mutex.Unlock()
  6.     x := *p
  7.     *p++
  8.     return x
  9. }

不过，你可能还会将next功能、状态和sync.Mutex组合成一个单一的结构体。

虽然在这种情况下没有理由这样做，因为Mutex更适合用于互斥访问单个资源，但你可以使用goroutines和channels来实现相同的效果。

  1. x := 0
  3. var wg sync.WaitGroup
  4. send := make(chan *int)
  5. recv := make(chan int)
  7. go func() {
  8.     for i := range send {
  9.         x := *i
  10.         *i++
  11.         recv <- x
  12.     }
  13. }()
  15. for i := 0; i < 10; i++ {
  16.     wg.Add(1)
  17.     go func() {
  18.         defer wg.Done()
  19.         send <- &x
  20.         fmt.Println(<-recv)
  21.     }()
  22. }
  23. wg.Wait()
  24. fmt.Println(x)

你可以在这里查看示例代码：http://play.golang.org/p/RR4TQXf2ct

英文:

You would use an actual sync.Mutex:

  1. var mutex sync.Mutex
  3. func next(p *int) int {
  4. 	mutex.Lock()
  5. 	defer mutex.Unlock()
  6. 	x := *p
  7. 	*p++
  8. 	return x
  9. }

Though you would probably also group the next functionality, state and sync.Mutex into a single struct.

Though there's no reason to do so in this case, since a Mutex is better suited for mutual exclusion around a single resource, you can use goroutines and channels to achieve the same effect

http://play.golang.org/p/RR4TQXf2ct

  1. x := 0
  3. var wg sync.WaitGroup
  4. send := make(chan *int)
  5. recv := make(chan int)
  7. go func() {
  8. 	for i := range send {
  9. 		x := *i
  10. 		*i++
  11. 		recv &lt;- x
  12. 	}
  13. }()
  15. for i := 0; i &lt; 10; i++ {
  16. 	wg.Add(1)
  17. 	go func() {
  18. 		defer wg.Done()
  19. 		send &lt;- &amp;x
  20. 		fmt.Println(&lt;-recv)
  21. 	}()
  22. }
  23. wg.Wait()
  24. fmt.Println(x)

答案2

得分: 1

如@favoretti所提到的，sync/atomic是一种实现的方法。

但是，你必须使用int32或int64而不是int（因为int在不同的平台上可能有不同的大小）。

这里有一个在Playground上的示例：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"sync/atomic"
  6. )
  8. func main() {
  9. 	done := make(chan int)
  10. 	x := int64(0)
  11. 	for i := 0; i < 10; i++ {
  12. 		go func() {
  13. 			y := next(&x)
  14. 			fmt.Println(y)
  15. 			done <- 0
  16. 		}()
  17. 	}
  18. 	for i := 0; i < 10; i++ {
  19. 		<-done
  20. 	}
  21. 	fmt.Println(x)
  23. }
  25. func next(p *int64) int64 {
  26. 	return atomic.AddInt64(p, 1) - 1
  27. }
英文:

As @favoretti mentioned, sync/atomic is a way to do it.

But, you have to use int32 or int64 rather than int (since int can be different sizes on different platforms).

Here's an example on Playground

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;sync/atomic&quot;
  6. )
  8. func main() {
  9. 	done := make(chan int)
  10. 	x := int64(0)
  11. 	for i := 0; i &lt; 10; i++ {
  12. 		go func() {
  13. 			y := next(&amp;x)
  14. 			fmt.Println(y)
  15. 			done &lt;- 0
  16. 		}()
  17. 	}
  18. 	for i := 0; i &lt; 10; i++ {
  19. 		&lt;-done
  20. 	}
  21. 	fmt.Println(x)
  23. }
  25. func next(p *int64) int64 {
  26. 	return atomic.AddInt64(p, 1) - 1
  27. }

huangapple
  • 本文由 发表于 2015年9月26日 17:46:11
  • 转载请务必保留本文链接：https://go.coder-hub.com/32795785.html
  • concurrency
  • go
匿名

发表评论

匿名网友

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

确定