乐趣区

关于golang:Go并发编程之传统同步3原子操作

jiezi

前言

之前文章中介绍的互斥锁尽管可能保障同串行化，然而却保障不了执行过程中的中断。
要么胜利、要么失败，没有中断的状况，咱们叫它叫原子性，这种由硬件 CPU 提供反对的个性，是十分牢靠的。

百度百科上对于原子操作的介绍。

原子操作

由 sync/atomic 包提供操作反对。

加法（add）

实现累加 

func TestDemo1(t *testing.T) {
    var counter int64 = 0

    for i := 0; i < 100; i++ {go func() {atomic.AddInt64(&counter, 1)
        }()}

    time.Sleep(2 * time.Second)
    log.Println("counter:", atomic.LoadInt64(&counter))
}

后果 

=== RUN   TestDemo1
2020/10/11 00:24:56 counter: 100
--- PASS: TestDemo1 (2.00s)
PASS

减法（add）

对于做减法，是没有间接提供的办法的，而 Add（-1）这种是不能对 uint 类型应用的，能够通过补码的形式实现 

func TestDemo2(t *testing.T) {
    var counter uint64 = 100

    for i := 0; i < 100; i++ {go func() {atomic.AddUint64(&counter, ^uint64(-(-1)-1))
        }()}

    time.Sleep(2 * time.Second)
    log.Println("counter:", atomic.LoadUint64(&counter))
}

后果 

=== RUN   TestDemo2
2020/10/11 00:32:05 counter: 0
--- PASS: TestDemo2 (2.00s)
PASS

比拟并替换（compare and swap，简称 CAS）

并发编程中，在没有应用互斥锁的前提下，对共享数据先取出做判断，再依据判断的后果做后续操作，必然是会出问题的，应用 CAS 能够防止这种问题。

func TestDemo3(t *testing.T) {
    var first int64 = 0

    for i := 1; i <= 10000; i++ {go func(i int) {if atomic.CompareAndSwapInt64(&first, 0, int64(i)) {log.Println("领先运行的是 goroutine", i)
            }
        }(i)
    }

    time.Sleep(2 * time.Second)
    log.Println("num:", atomic.LoadInt64(&first))
}

后果 

=== RUN   TestDemo3
2020/10/11 00:42:10 领先运行的是 goroutine 3
2020/10/11 00:42:12 num: 3
--- PASS: TestDemo3 (2.01s)
PASS

加载（load）

加载操作在进行时只会有一个，不会有其它的读写操作同时进行。

func TestDemo4(t *testing.T) {
    var counter int64 = 0

    for i := 0; i < 100; i++ {go func() {atomic.AddInt64(&counter, 1)
            log.Println("counter:", atomic.LoadInt64(&counter))
        }()}

    time.Sleep(2 * time.Second)
}

存储（store）

存储操作在进行时只会有一个，不会有其它的读写操作同时进行。

func TestDemo5(t *testing.T) {
    var counter int64 = 0

    for i := 0; i < 10; i++ {go func(i int) {atomic.StoreInt64(&counter, int64(i))
            log.Println("counter:", atomic.LoadInt64(&counter))
        }(i)
    }

    time.Sleep(2 * time.Second)
}

替换（swap）

swap 办法返回被替换之前的旧值。

func TestDemo6(t *testing.T) {
    var counter int64 = 0

    for i := 0; i < 10; i++ {go func(i int) {log.Println("counter old:", atomic.SwapInt64(&counter, int64(i)))
        }(i)
    }

    time.Sleep(2 * time.Second)
}

后果 

=== RUN   TestDemo6
2020/10/11 00:43:36 counter old: 0
2020/10/11 00:43:36 counter old: 9
2020/10/11 00:43:36 counter old: 5
2020/10/11 00:43:36 counter old: 1
2020/10/11 00:43:36 counter old: 2
2020/10/11 00:43:36 counter old: 3
2020/10/11 00:43:36 counter old: 6
2020/10/11 00:43:36 counter old: 4
2020/10/11 00:43:36 counter old: 7
2020/10/11 00:43:36 counter old: 0
--- PASS: TestDemo6 (2.00s)
PASS

原子值（value）

value 是一个构造体，外部值定义为 interface{}，所以它是能够承受任何类型的值。

第一次赋值的时候，原子值的类型就确认了，前面不能赋值其它类型的值。

func TestDemo7(t *testing.T) {
    var value atomic.Value
    var counter uint64 = 1

    value.Store(counter)
    log.Println("counter:", value.Load())

    value.Store(uint64(10))
    log.Println("counter:", value.Load())

    value.Store(100) // 引发 panic
    log.Println("counter:", value.Load())

    time.Sleep(2 * time.Second)
}

后果 

=== RUN   TestDemo7
2020/10/11 10:14:58 counter: 0
2020/10/11 10:14:58 counter: 10
--- FAIL: TestDemo7 (0.00s)
panic: sync/atomic: store of inconsistently typed value into Value [recovered]
    panic: sync/atomic: store of inconsistently typed value into Value
                ...
Process finished with exit code 1

扩大

无锁编程

此处临时先介绍一下，前面有机会出文章再一起学习提高。

放弃互斥锁，采纳原子操作，常见办法有以下几种：

针对计数器

能够应用例如下面介绍的 Add 办法。

单生产、消费者

单生产者、单消费者能够做到免锁拜访环形缓冲区（Ring Buffer）。\
比方，Linux kernel 中的 kfifo 的实现。

RCU（Read Copy Update）

新旧正本切换机制，对于旧正本能够采纳提早开释的做法。

CAS（Compare And Swap）

如无锁栈，无锁队列期待

总结

  1. 原子操作性能是高于互斥锁的，但带来的复杂性也会进步，真正用好并不容易。
  2. 互斥锁、条件变量，办法外部的实现也都用到了原子操作，特地是 CAS。

文章示例代码

退出移动版