sync.atomic

Golang 标准库中的 sync/atomic 为开发者提供了对几种简单类型的原子操作函数。这些简单类型包括int32, int64, uint32, uint64, uintptr, unsafe.Pointer。这些原子操作函数有以下5种：增减（Add），存储（Store），载入（Load），交换（Swap），比较并交换（CompareAndSwap）。

sync.atomic 与 sync.Mutex 对比

对比实验源码：

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)

func main() {
    test1()
    test2()
}

// sync.Mutex
func test1() {
    var wg sync.WaitGroup
    var mutex sync.Mutex
    count := int64(0)
    t := time.Now()
    for i := 0; i < 10000; i++ {
        wg.Add(1)
        go func(i int) {
            mutex.Lock()
            count++
            wg.Done()
            mutex.Unlock()
        }(i)
    }

    wg.Wait()

    fmt.Printf("test1 花费时间：%d, count的值为：%d \n", time.Now().Sub(t), count)
}

// sync.atomic
func test2() {
    var wg sync.WaitGroup
    count := int64(0)
    t := time.Now()
    for i := 0; i < 10000; i++ {
        wg.Add(1)
        go func(i int) {
            atomic.AddInt64(&count, 1)
            wg.Done()
        }(i)
    }

    wg.Wait()

    fmt.Printf("test2 花费时间：%d, count的值为：%d \n", time.Now().Sub(t), count)
}

对比实验运行结果：

test1 花费时间：4514661, count的值为：10000
test2 花费时间：3361215, count的值为：10000

test1，test2 函数分别通过 sync.Mutex 和 sync.atomic 提供的原子操作函数实现对一个 int64 整数进行 10000 次多线程安全的加法运算。通过实验运行结果可知，sync.atomic 比 sync.Mutex 的执行效率更高。

sync.atomic 的实现原理大致是向 CPU 发送对某一个块内存的 LOCK 信号，然后就将此内存块加锁，从而保证了内存块操作的原子性。这种对 CPU 发送信号对内存加锁的方式，比 sync.Mutex 这种在语言层面对内存加锁的方式更底层，因此也更高效。

除此之外，sync.atomic 避免了加锁、解锁的过程，一行代码就可以完成线程安全操作，也比 sync.Mutex 更简洁，代码可读性更强。