如何实现原子加法，但不超过 x？

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

how to implement atomic add but not exceed x?

问题

我想要在纯原子操作中实现以下的add函数：

  1. var num int
  2. func add(max int) int {
  3.   if num < max {
  4.     num++
  5.   }
  6.   return num
  7. }

我尝试了一个版本：

  1. func add(max int64) int64 {
  2. 	for {
  3. 		old := atomic.LoadInt64(&x)
  4. 		if old + 1 < max {
  5. 			if atomic.CompareAndSwapInt64(&x, old, old+1) {
  6. 				return old+1
  7. 			}
  8. 		} else {
  9. 			return old
  10. 		}
  11. 	}
  12. }

然而，我猜想可能有一种更好的解决方案，可以减少失败的机会并避免死循环。

英文:

i want to implement add below in pure atomic operation

  1. var num int
  2. func add(max int) int {
  3.   if num &lt; max {
  4.     num++
  5.   }
  6.   return num
  7. }

i have try one edition

  1. func add(max int64) int64 {
  2. 	for {
  3. 		old := atomic.LoadInt64(&amp;x)
  4. 		if old + 1 &lt; max {
  5. 			if atomic.CompareAndSwapInt64(&amp;x, old, old+1) {
  6. 				return old+1
  7. 			}
  8. 		} else {
  9. 			return old
  10. 		}
  11. 	}
  12. }

however, i guess there might be a better solution with less fail chance and avoid dead loop

答案1

得分: 1

这是您的算法的修订版本，其中包含了多个goroutine的测试。它通过了带有和不带有Go竞争检测器的测试。

add.go:

  1. package main
  3. import (
  4.     "fmt"
  5.     "runtime"
  6.     "sync"
  7.     "sync/atomic"
  8. )
  10. var x int64 = -42
  12. func add(max int64) int64 {
  13.     for {
  14.         old := atomic.LoadInt64(&x)
  15.         if old >= max {
  16.             return old
  17.         }
  18.         new := old + 1
  19.         if atomic.CompareAndSwapInt64(&x, old, new) {
  20.             return new
  21.         }
  22.     }
  23. }
  25. func main() {
  26.     const max = 123456
  27.     fmt.Println("max:", max)
  28.     fmt.Println("x:  ", x)
  29.     var wg sync.WaitGroup
  30.     procs := runtime.GOMAXPROCS(0)
  31.     for i := 0; i < procs; i++ {
  32.         wg.Add(1)
  33.         go func(max int64) {
  34.             defer wg.Done()
  35.             for {
  36.                 if add(max) >= max {
  37.                     return
  38.                 }
  39.             }
  40.         }(max)
  41.     }
  42.     wg.Wait()
  43.     fmt.Println("x:  ", x)
  45. }

https://go.dev/play/p/r-qsnyI7tqv

  1. $ go build -race add.go && ./add
  2. max: 123456
  3. x:   -42
  4. x:   123456
  5. $ go build add.go && ./add
  6. max: 123456
  7. x:   -42
  8. x:   123456
英文:

Here's a revised version of your algorithm with a multiple goroutine test. It passes the test with and without the Go race detector.

add.go:

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;runtime&quot;
  6. 	&quot;sync&quot;
  7. 	&quot;sync/atomic&quot;
  8. )
  10. var x int64 = -42
  12. func add(max int64) int64 {
  13. 	for {
  14. 		old := atomic.LoadInt64(&amp;x)
  15. 		if old &gt;= max {
  16. 			return old
  17. 		}
  18. 		new := old + 1
  19. 		if atomic.CompareAndSwapInt64(&amp;x, old, new) {
  20. 			return new
  21. 		}
  22. 	}
  23. }
  25. func main() {
  26. 	const max = 123456
  27. 	fmt.Println(&quot;max:&quot;, max)
  28. 	fmt.Println(&quot;x:  &quot;, x)
  29. 	var wg sync.WaitGroup
  30. 	procs := runtime.GOMAXPROCS(0)
  31. 	for i := 0; i &lt; procs; i++ {
  32. 		wg.Add(1)
  33. 		go func(max int64) {
  34. 			defer wg.Done()
  35. 			for {
  36. 				if add(max) &gt;= max {
  37. 					return
  38. 				}
  39. 			}
  40. 		}(max)
  41. 	}
  42. 	wg.Wait()
  43. 	fmt.Println(&quot;x:  &quot;, x)
  45. }

https://go.dev/play/p/r-qsnyI7tqv

  1. $ go build -race add.go &amp;&amp; ./add
  2. max: 123456
  3. x:   -42
  4. x:   123456
  5. $ go build add.go &amp;&amp; ./add
  6. max: 123456
  7. x:   -42
  8. x:   123456

答案2

得分: 0

最简单（但不是最高效）的解决方案是使用互斥锁：

  1. var (
  2.     mu  sync.Mutex
  3.     num int64
  4. )
  6. func add(max int64) int64 {
  7.     mu.Lock()
  8.     defer mu.Unlock()
  10.     if num < max {
  11.         num++
  12.     }
  13.     return num
  14. }

请注意，这段代码使用了互斥锁（sync.Mutex）来确保在修改 num 变量时的线程安全性。mu.Lock() 用于获取锁，mu.Unlock() 用于释放锁。在 add 函数中，我们首先获取锁，然后在修改 num 变量之前检查其值是否小于 max。如果是，则将 num 递增。最后，我们释放锁并返回 num 的值。

英文:

The easiest (but not the most efficient) solution would be to use a mutex:

  1. var (
  2. 	mu  sync.Mutex
  3. 	num int64
  4. )
  6. func add(max int64) int64 {
  7. 	mu.Lock()
  8. 	defer mu.Unlock()
  10. 	if num &lt; max {
  11. 		num++
  12. 	}
  13. 	return num
  14. }

huangapple
  • 本文由 发表于 2021年12月23日 16:11:43
  • 转载请务必保留本文链接：https://go.coder-hub.com/70459327.html
  • atomic
  • go
匿名

发表评论

匿名网友

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

确定