Lock-Free的栈实现及与加锁实现的性能对比

　　在编写多线程程序时，临界资源的处理常常需要互斥量、读写锁等来加以保护。这时需要考虑锁的粒度问题，粒度太粗，会出现很多线程阻塞等待相同的锁，源自并发性的改善微乎其微；如果锁的粒度太细，那么过多的锁开销会使系统性能受到影响，而且代码变得相当复杂。除此之外，还要细致的考虑各种dead lock问题。

　　因此，对于某些关键数据结构（临界资源），可以考虑使用Lock Free的实现手段。一个Lock Free的程序能够确保执行它的所有线程至少有一个能够继续往下执行，从而免疫了死锁等问题。Lock Free算法需要对应的原子操作加以支持，比如CAS(compare-and-swap)及其变种。CAS实现的逻辑如下：

bool CAS(inptr_t* addr, intptr_t oldv, intptr_t newv)
atomically{
     if(*addr == oldv)
     {
          *addr = newv;
          return true;
     }
     else
　   {
     return false
     }

}

      接下来给出有锁和无锁的栈实现，以及最后的性能测试数据。

      有锁实现的栈：

      lock_stack.h

 1 #ifndef __LOCK_STACK_H
 2 #define __LOCK_STACK_H
 3 #include<pthread.h>
 4 
 5 typedef int value_t;
 6 
 7 struct cell
 8 {
 9     struct cell *next;
10     value_t value;
11 };
12 
13 struct stack
14 {
15     struct cell *top;
16     pthread_mutex_t lock;
17 };
18 
19 struct stack *stack_alloc(void);
20 void stack_push(struct stack *fp,struct cell *cl);
21 struct cell *stack_pop(struct stack *fp);
22 
23 #endif

　　lock_stack.c

 1 #include "lock_stack.h"
 2 #include <pthread.h>
 3 #include <stdlib.h>
 4 
 5 struct stack *stack_alloc(void)
 6 {
 7     struct stack *fp;
 8     if((fp = (struct stack*)malloc(sizeof(struct stack))) != NULL)
 9     {
10         fp->top = NULL;
11         if(pthread_mutex_init(&fp->lock,NULL) != 0)
12         {
13             free(fp);
14             return NULL;
15         }
16     }
17     return fp;
18 }
19 
20 void stack_push(struct stack *fp,struct cell *cl)
21 {
22     pthread_mutex_lock(&fp->lock); 
23     
24     cl->next = fp->top;
25     fp->top = cl; 
26 
27     pthread_mutex_unlock(&fp->lock); 
28 }
29 
30 struct cell *stack_pop(struct stack *fp)
31 {
32     cell *head;
33     pthread_mutex_lock(&fp->lock); 
34     
35     head = fp->top;
36     if(head == NULL)
37     {
38         pthread_mutex_unlock(&fp->lock); 
39         return head;
40     }
41 
42     fp->top = head->next;
43     pthread_mutex_unlock(&fp->lock); 
44 }

　　无锁实现的栈：

　　lock_free_stack.h

 1 #ifndef __LOCK_FREE_STACK_H
 2 #define __LOCK_FREE_STACK_H
 3 #include<pthread.h>
 4 
 5 typedef int value_t;
 6 
 7 struct cell
 8 {
 9     struct cell *next;
10     value_t value;
11 };
12 
13 struct stack
14 {
15     struct cell *top;
16 };
17 
18 struct stack *stack_alloc(void);
19 void stack_push(struct stack *fp,struct cell *cl);
20 struct cell *stack_pop(struct stack *fp);
21 
22 #endif

　　lock_free_stack.c

 1 #include "lock_free_stack.h"
 2 #include <pthread.h>
 3 #include <stdlib.h>
 4 
 5 struct stack *stack_alloc(void)
 6 {
 7     struct stack *fp;
 8     if((fp = (struct stack*)malloc(sizeof(struct stack))) != NULL)
 9     {
10         fp->top = NULL;
11     }
12     return fp;
13 }
14 
15 void stack_push(struct stack *fp,struct cell *cl)
16 {
17     do{
18         cl->next = fp->top;
19     }while(!__sync_bool_compare_and_swap(&fp->top,cl->next,cl));
20 }
21 
22 struct cell *stack_pop(struct stack *fp)
23 {
24     cell *head,*next;
25     
26     do
27     {
28         head = fp->top;
29         if(head == NULL)
30         {
31             break;
32         }
33         next = head->next; 
34     }while(!__sync_bool_compare_and_swap(&fp->top,head,next));
35     return head;
36 }

　　主程序使用100个线程，每个线程对同一栈进行500000次随机的push/pop操作（具体进行某个操作rand确定），并记录了每个线程的执行时间，代码如下：

 1 #ifdef __LOCK_VERSION
 2     #include "lock_stack.h"
 3 #endif
 4 #ifdef __LOCK_FREE_VERSION
 5     #include "lock_free_stack.h"
 6 #endif
 7 #include <stdlib.h>
 8 #include <stdio.h>
 9 #include <unistd.h>
10 #include <time.h>
11 
12 void* thr_fn(void *fp)
13 {
14     time_t t1 = time(NULL);
15     for(int i = 0; i != 500000; i++)
16     {
17         int r = rand()%2;
18         struct cell *cl;
19         
20     　　if(r == 0)
21     　　{
22         　　if((cl = (struct cell*)malloc(sizeof(struct cell))) != NULL)
23         　　{
24         　　　　stack_push((struct stack*)fp,cl);
25         　　}
26         　　printf("push!\n");
27     　　}
28     　　else 
29     　　{
30        　　 cl = stack_pop((struct stack*)fp);
31         　　if(cl != NULL)
32         　　{
33                 //free(cl); 
34         　　}
35         　　printf("pop!\n");
36         }
37     } 
38 
39     printf("cost time: %d\n",time(NULL)-t1);
40 
41     return NULL;
42 }
43 
44 int main()
45 {
46     struct stack *fp;
47     fp = stack_alloc();
48 
49     pthread_t tid;
50     for(int i = 0; i < 100; i++)
51     {
52         pthread_create(&tid,NULL,thr_fn,(void *)fp);
53     }
54     
55     sleep(1000);
56 
57     return 0;
58 }

　　makefile文件如下：

1 lock_free:
2     g++ lock_free_stack.c main.c -lpthread -D__LOCK_FREE_VERSION -march=nocona -o lock_free
3 lock:
4     g++ lock_stack.c main.c -lpthread -D__LOCK_VERSION -o lock
5 
6 clean:
7     rm lock lock_free

　　得到最终的测试数据如下所示：

　　相比较而言，在性能上lock_free_stack有微弱的优势。

注：

1）大家在看代码时可能已经注意到了，main.c 33行free()函数被注释掉了，这是有意为之，在主动进行内存管理时，Lock Free结构会遇到ABA问题，需要CAS2配合Sequence Number加以解决。感兴趣的读者可以继续阅读文后的参考文献；

2）主线程需要等待所有的子线程执行完毕，这里不好使用pthread_join，本文作者采用取巧的办法，调用sleep函数进行等待，具体等待时间可能和测试环境相关；

3）__sync_bool_compare_and_swap 是由GCC提供的内置函数（GCC 4.1或更高版本），编译时需要指定-march参数；

 

参考资料：

[1]搜狗实验室 　　C10K与高性能程序续篇　　http://www.sogou.com/labs/report/4-2.pdf

[2]W.Richard Stevens     Advanced Programming in the Unix Environment　　11.6节 线程同步

[3]设计不适用互斥锁的并发数据结构  http://www.ibm.com/developerworks/cn/aix/library/au-multithreaded_structures2/

[4]解决了“undefined reference to `__sync_bool_compare_and_swap_4”的编译错误   http://raylinn.iteye.com/blog/347323

[5]compare_and_swap　　http://en.wikipedia.org/wiki/Compare-and-swap