1 简介

代码中的加锁操作因为涉及内核态的上下文切换会比较耗时、代价比较高。针对基本数据类型我们还可以使用原子操作来保证并发安全，因为原子操作是Go语言提供的方法, 它在用户态就可以完成，因此性能比加锁操作更好。

2 代码示例

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6.     "sync/atomic"
  7.     "time"
  8. )
  10. var x int64
  11. var l sync.Mutex
  12. var wg sync.WaitGroup
  14. // 普通版加函数
  15. func add() {
  16.     // x = x + 1
  17.     x++ // 等价于上面的操作
  18.     wg.Done()
  19. }
  21. // 互斥锁版加函数
  22. func mutexAdd() {
  23.     l.Lock()
  24.     x++
  25.     l.Unlock()
  26.     wg.Done()
  27. }
  29. // 原子操作版加函数
  30. func atomicAdd() {
  31.     atomic.AddInt64(&x, 1)
  32.     wg.Done()
  33. }
  35. func main() {
  36.     start := time.Now()
  37.     for i := 0; i < 1000000; i++ {
  38.         wg.Add(1)
  39.         //go add() // 普通版add函数 不是并发安全的 241.894648ms
  40.         //go mutexAdd() // 加锁版add函数 是并发安全的，但是加锁性能开销大 302.15573ms
  41.         go atomicAdd() // 原子操作版add函数 是并发安全，性能优于加锁版 251.501716ms
  42.     }
  43.     wg.Wait()
  44.     end := time.Now()
  45.     fmt.Println(x)
  46.     fmt.Println(end.Sub(start))
  47. }