CAS原子操作实现无锁及性能分析

Posted 2022-11-27 xuhao_xuhao

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了CAS原子操作实现无锁及性能分析相关的知识，希望对你有一定的参考价值。

Author：Echo Chen（陈斌）
Email：chenb19870707@gmail.com
Blog：Blog.csdn.net/chen19870707
Date：Nov 13th, 2014

最近在研究nginx的自旋锁的时候，又见到了GCC CAS原子操作，于是决定动手分析下CAS实现的无锁到底性能如何，网上关于CAS实现无锁的文章很多，但少有研究这种无锁的性能提升的文章，这里就以实验结果和我自己的理解逐步展开。
1.什么是CAS原子操作
在研究无锁之前，我们需要首先了解一下CAS原子操作——Compare & Set，或是 Compare & Swap，现在几乎所有的CPU指令都支持CAS的原子操作，X86下对应的是 CMPXCHG 汇编指令。

大家应该还记得操作系统里面关于“原子操作”的概念，一个操作是原子的(atomic)，如果这个操作所处的层(layer)的更高层不能发现其内部实现与结构。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。有了这个原子操作这个保证我们就可以实现无锁了。

CAS原子操作在维基百科中的代码描述如下:
```
   1: int compare_and_swap(int* reg, int oldval, int newval)
```
```
   2: 
```
```
   3:   ATOMIC();
```
```
   4:   int old_reg_val = *reg;
```
```
   5:   if (old_reg_val == oldval)
```
```
   6:      *reg = newval;
```
```
   7:   END_ATOMIC();
```
```
   8:   return old_reg_val;
```
```
   9: 
```
也就是检查内存*reg里的值是不是oldval，如果是的话，则对其赋值newval。上面的代码总是返回old_reg_value，调用者如果需要知道是否更新成功还需要做进一步判断，为了方便，它可以变种为直接返回是否更新成功，如下：

   1: bool compare_and_swap (int *accum, int *dest, int newval)

2:

   3:   if ( *accum == *dest )

   4:       *dest = newval;

   5:       return true;

6:

   7:   return false;

8:

除了CAS还有以下原子操作：

Fetch And Add，一般用来对变量做 +1 的原子操作。

   1: << atomic >>

   2: function FetchAndAdd(address location, int inc)

   3:     int value := *location

   4:     *location := value + inc

   5:     return value

6:

Test-and-set，写值到某个内存位置并传回其旧值。汇编指令BST。

   1: #define LOCKED 1

2:

   3: int TestAndSet(int* lockPtr)

   4:     int oldValue;

5:

   6:     // Start of atomic segment

   7:     // The following statements should be interpreted as pseudocode for

   8:     // illustrative purposes only.

   9:     // Traditional compilation of this code will not guarantee atomicity, the

  10:     // use of shared memory (i.e. not-cached values), protection from compiler

  11:     // optimization, or other required properties.

  12:     oldValue = *lockPtr;

  13:     *lockPtr = LOCKED;

  14:     // End of atomic segment

15:

  16:     return oldValue;

17:

Test and Test-and-set，用来实现多核环境下互斥锁，

   1: boolean locked := false // shared lock variable

   2: procedure EnterCritical()

   3:   do

   4:     while (locked == true) skip // spin until lock seems free

   5:    while TestAndSet(locked) // actual atomic locking

6:

2.CAS 在各个平台下的实现

2.1 Linux GCC 支持的 CAS

GCC4.1+版本中支持CAS的原子操作（完整的原子操作可参看 GCC Atomic Builtins）
   1: bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...)
   2: type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...)

2.2 Windows支持的CAS

在Windows下，你可以使用下面的Windows API来完成CAS：（完整的Windows原子操作可参看MSDN的InterLocked Functions）

   1: InterlockedCompareExchange ( __inout LONG volatile *Target,

   2:                                 __in LONG Exchange,

   3:                                 __in LONG Comperand);

2.3 C++ 11支持的CAS

C++11中的STL中的atomic类的函数可以让你跨平台。（完整的C++11的原子操作可参看 Atomic Operation Library）

   1: template< class T >

   2: bool atomic_compare_exchange_weak( std::atomic<T>* obj,

   3:                                    T* expected, T desired );

   4: template< class T >

   5: bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj,

   6:                                    T* expected, T desired );

3.CAS原子操作实现无锁的性能分析

3.1测试方法描述

这里由于只是比较性能，所以采用很简单的方式，创建10个线程并发执行，每个线程中循环对全局变量count进行++操作（i++)，循环加2000000次，这必然会涉及到并发互斥操作，在同一台机器上分析加普通互斥锁、CAS实现的无锁、Fetch And Add实现的无锁消耗的时间，然后进行分析。

3.2 加普通互斥锁代码

   1: #include <stdio.h>

   2: #include <stdlib.h>

   3: #include <pthread.h>

   4: #include <time.h>

   5: #include "timer.h"

6:

   7: pthread_mutex_t mutex_lock;

   8: static volatile int count = 0;

   9: void *test_func(void *arg)

10:

  11:         int i = 0;

  12:         for(i = 0; i < 2000000; i++)

13:

  14:                 pthread_mutex_lock(&mutex_lock);

  15:                 count++;

  16:                 pthread_mutex_unlock(&mutex_lock);

17:

  18:         return NULL;

19:

20:

  21: int main(int argc, const char *argv[])

22:

  23:     Timer timer; // 为了计时，临时封装的一个类Timer。

  24:     timer.Start();    // 计时开始

  25:     pthread_mutex_init(&mutex_lock, NULL);

  26:     pthread_t thread_ids[10];

  27:     int i = 0;

  28:     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)

29:

  30:         pthread_create(&thread_ids[i], NULL, test_func, NULL);

31:

32:

  33:     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)

34:

  35:         pthread_join(thread_ids[i], NULL);

36:

37:

  38:     timer.Stop();// 计时结束

  39:     timer.Cost_time();// 打印花费时间

  40:     printf("结果:count = %d\\n",count);

41:

  42:     return 0;

43:

注：Timer类仅作统计时间用，其实现在文章最后给出。

3.2 CAS实现的无锁

   1: #include <stdio.h>

   2: #include <stdlib.h>

   3: #include <pthread.h>

   4: #include <unistd.h>

   5: #include <time.h>

   6: #include "timer.h"

7:

   8: int mutex = 0;

   9: int lock = 0;

  10: int unlock = 1;

11:

  12: static volatile int count = 0;

  13: void *test_func(void *arg)

14:

  15:         int i = 0;

  16:         for(i = 0; i < 2000000; i++)

17:

  18:         while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ))usleep(100000);

  19:          count++;

  20:          __sync_bool_compare_and_swap (&mutex, unlock, 0);

21:

  22:         return NULL;

23:

24:

  25: int main(int argc, const char *argv[])

26:

  27:     Timer timer;

  28:     timer.Start();

  29:     pthread_t thread_ids[10];

  30:     int i = 0;

31:

  32:     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)

33:

  34:             pthread_create(&thread_ids[i], NULL, test_func, NULL);

35:

36:

  37:     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)

38:

  39:             pthread_join(thread_ids[i], NULL);

40:

41:

原子操作实现无锁队列

CAS 与原子操作

多线程九原子类

无锁队列的实现(陈皓)

Android-CAS与原子变量（无锁并发和有锁并发）

CAS原子操作实现无锁及性能分析

1.什么是CAS原子操作

2.CAS 在各个平台下的实现

2.1 Linux GCC 支持的 CAS

2.2 Windows支持的CAS

2.3 C++ 11支持的CAS

3.CAS原子操作实现无锁的性能分析

3.1测试方法描述

3.2 加普通互斥锁代码

3.2 CAS实现的无锁