【最终版 & 总结】自实现自旋锁 与 mutex，spinlock比较（结果令人吃惊）

ydfgic

总结一下：
最后修改了一下测试代码，比较方便的设置线程数，选择测试对象，设置delay的参数。
经过测试发现我的实现测试的结果时间非常稳定，2个，10个，20个乃至40个线程的差别很小，几乎达到了与线程数无关，同样mutex也是和线程数关系不大，但是pthread_spinlock_t对线程数敏感，线程多的情况下，效率会降低很多。
同样增加加锁的粒度，对测试结果也有影响，当粒度很小的情况下，我的实现是mutex的4-5倍快，但是粒度很大的情况，比如我设置到delay的循环次数为1000时，效率是mutex的两倍多快，但是cpu更忙些。spinlock的速度就不提了，很低。
结论：
如果是比较大粒度的加锁肯定是mutex首选，虽然性能中庸，但是它因为会休眠挂起，不占用cpu，对系统影响小。
如果是比较细粒度的加锁可以用我实现的lock，对线程数量几乎无关，效率极高，可能是因为实现简单，最大效率的做到了切换cpu，保证一个线程执行，减少了多余环节。
pthread_spinlock_t的局限性太大，如果线程多的情况下，会造成性能的很大程度的损失。同时还仅限于小粒度的加锁情况。

给出测试数据：
1）20线程，0delay
我的：time ./myspinlock_O3.out 20 0 0
real    0m0.323s
user    0m0.364s
sys     0m0.276s

mutex：time ./myspinlock_O3.out 20 1 0
real    0m1.634s
user    0m1.972s
sys     0m1.264s

spinlock: time ./myspinlock_O3.out 20 2 0
real    0m6.259s
user    0m12.477s
sys     0m0.004s

2）20线程，100 delay
我的：time ./myspinlock_O3.out 20 0 100
real    0m2.965s
user    0m3.268s
sys     0m2.636s

mutex：time ./myspinlock_O3.out 20 1 100
real    0m6.493s
user    0m6.344s
sys     0m6.604s

spinlock： time ./myspinlock_O3.out 20 2 100
real    0m15.760s
user    0m31.378s
sys     0m0.004s

3）10线程，0delay
我的：time ./myspinlock_O3.out 10 0 0
real    0m0.318s
user    0m0.372s
sys     0m0.248s
mutex：time ./myspinlock_O3.out 10 1 0
real    0m1.511s
user    0m1.808s
sys     0m1.200s
spinlock：time ./myspinlock_O3.out 10 2 0
real    0m3.625s
user    0m7.224s
sys     0m0.004s

4）2线程，0delay
我的：time ./myspinlock_O3.out 2 0 0
real    0m0.323s
user    0m0.376s
sys     0m0.184s
mutex：time ./myspinlock_O3.out 2 1 0
real    0m1.453s
user    0m1.688s
sys     0m1.136s
spinlock：time ./myspinlock_O3.out 2 2 0
real    0m0.819s
user    0m1.624s
sys     0m0.004s


最终版的实现

1. #include<stdint.h>
   
2. #include<unistd.h>
   
3. 
   
4. typedef volatile uint32_t spinlock_t;
   
5. 
   
6. #define MY_SPINLOCK_INITIALIZER 0
   
7. 
   
8. #define spinlock_lock(lock) do{  \
   
9.     while(!__sync_bool_compare_and_swap(lock, 0, 1))    \
   
10.         sched_yield();  \
    
11. }while(0)
    
12. 
    
13. #define spinlock_unlock(lock) do{    \
    
14.     *lock = 0;  \
    
15. }while(0)

复制代码

最终版的测试代码

1. #include"myspinlock.h"
   
2. 
   
3. // gcc -Wall -g -O3 -o myspinlock.out myspinlock.c -lpthread
   
4. 
   
5. 
   
6. /////////////////////////                test  
   
7. 
   
8. my_spinlock_t lock =  MY_SPINLOCK_INITIALIZER;
   
9. volatile int cnt = 0;
   
10. 
    
11. #include<pthread.h>
    
12. #include<stdio.h>
    
13. #include <stdlib.h>
    
14. 
    
15. #define  TOTAL 1000000 * 20
    
16. int NR;
    
17. int DELAY_CNT = 100;
    
18. 
    
19. void * fun1(void * arg)
    
20. {
    
21.         int i = 0, id = *(int*)arg;
    
22.         printf("thread:%d\n",id);
    
23.         for(; i < NR; i++)
    
24.         {
    
25.                 spinlock_lock(&lock);
    
26.                 cnt++;
    
27.                 int j = 0;
    
28.                 for (; j < DELAY_CNT; j++) {
    
29.                         *foo = (*foo * 33) + 17;
    
30.                 }
    
31.                 spinlock_unlock(&lock);
    
32.         }
    
33.         printf("thread:%d over, lock:%d\n",id, lock);
    
34.         return 0;
    
35. }
    
36. 
    
37. pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;
    
38. 
    
39. void * fun2(void * arg)
    
40. {
    
41.         int i = 0, id = *(int*)arg;
    
42.         printf("thread:%d\n",id);
    
43.         for(; i < NR; i++)
    
44.         {
    
45.                 pthread_mutex_lock(&mlock);
    
46.                 cnt++;
    
47.                 int j = 0;
    
48.                 for (; j < DELAY_CNT; j++) {
    
49.                         *foo = (*foo * 33) + 17;
    
50.                 }
    
51.                 pthread_mutex_unlock(&mlock);
    
52.         }
    
53.         printf("thread:%d over, lock:%d\n",id, lock);
    
54.         return 0;
    
55. }
    
56. 
    
57. pthread_spinlock_t splock;
    
58. 
    
59. void * fun3(void * arg)
    
60. {
    
61.         int i = 0, id = *(int*)arg;
    
62.         printf("thread:%d\n",id);
    
63.         for(; i < NR; i++)
    
64.         {
    
65.                 pthread_spin_lock(&splock);
    
66.                 cnt++;
    
67.                 int j = 0;
    
68.                 for (; j < DELAY_CNT; j++) {
    
69.                         *foo = (*foo * 33) + 17;
    
70.                 }
    
71.                 pthread_spin_unlock(&splock);
    
72.         }
    
73.         printf("thread:%d over, lock:%d\n",id, lock);
    
74.         return 0;
    
75. }
    
76. 
    
77. int N = 20;
    
78. int main(int c, char * s[])
    
79. {
    
80.         int which = 0;
    
81.         if(c > 1)
    
82.         {
    
83.                 //线程数
    
84.                 N = atoi(s[1]);
    
85.                 if(N > 20 || N <= 1) N = 10;
    
86.         }
    
87.         if(c > 2)
    
88.         {
    
89.                 //which func?
    
90.                 which = atoi(s[2]);
    
91.                 if(which > 2 || which < 0) which = 0;
    
92.         }
    
93.         if(c > 3)
    
94.         {
    
95.                 //delay param
    
96.                 DELAY_CNT = atoi(s[3]);
    
97.                 if(DELAY_CNT > 10000 || DELAY_CNT < 0) DELAY_CNT= 100;
    
98.         }
    
99. 
    
100.         pthread_t id[N];
     
101.         int args[N];
     
102.         int i = 0;
     
103.         void * (*fun[])(void*) = { fun1,fun2,fun3};
     
104.         pthread_spin_init(&splock,0);
     
105.         NR = TOTAL / N;
     
106. 
     
107.         for(;i<N;++i){
     
108.                 args[i] = i;
     
109.                 pthread_create(&id[i],NULL,fun[which],&args[i]);
     
110.         }
     
111. 
     
112.         for(i=0;i<N;++i){
     
113.                 printf("join thread:%d\n", i);
     
114.                 pthread_join(id[i],NULL);
     
115.                 printf("join thread:%d done\n", i);
     
116.         }
     
117. 
     
118.         printf("cnt = %d, should be %d\n",cnt, N * NR);
     
119.         return 0;
     
120. }
     

复制代码

===============================================
先前的更新仅仅做为参考

更新
重新修改了我的实现，加入了放弃时间片的情况，测试结果，几乎是mutex的2-3倍效率
real    0m0.431s
user    0m0.604s
sys     0m0.240s

我想这个应该就会是我理想中的最终版本了，起码可以抛弃 pthread 库的mutex实现一些简单的加锁的功能。

代码：

1. #ifndef MY_SPINLOCK_H
   
2. #define MY_SPINLOCK_H
   
3. 
   
4. #include<stdint.h>
   
5. #include<unistd.h>
   
6. 
   
7. typedef volatile uint32_t my_spinlock_t;
   
8. 
   
9. #define MY_SPINLOCK_INITIALIZER 0
   
10. #define DELAY_NR 10000
    
11. 
    
12. static uint32_t bar = 13;
    
13. static uint32_t *foo = &bar;
    
14. 
    
15. #define do_hash(a) do{  \
    
16. (a) = ((a)+0x7ed55d16) + ((a)<<12); \
    
17. (a) = ((a)^0xc761c23c) ^ ((a)>>19); \
    
18. (a) = ((a)+0x165667b1) + ((a)<<5);  \
    
19. (a) = ((a)+0xd3a2646c) ^ ((a)<<9);  \
    
20. (a) = ((a)+0xfd7046c5) + ((a)<<3);  \
    
21. (a) = ((a)^0xb55a4f09) ^ ((a)>>16); \
    
22. }while(0)
    
23. 
    
24. #define my_spinlock_lock(lock) do{  \
    
25.     while(!__sync_bool_compare_and_swap(lock, 0, 1))    \
    
26.     {   \
    
27.         while(*lock)    \
    
28.         {   \
    
29.             do_hash(*foo);  \
    
30.             if((*foo % 11) == 1)    \
    
31.                 sched_yield();  \
    
32.         }   \
    
33.     }   \
    
34. }while(0)
    
35. 
    
36. #define my_spinlock_unlock(lock) do{    \
    
37.     *lock = 0;  \
    
38. }while(0)
    
39. 
    
40. #endif

复制代码

=======================================

最近在研究原子操作，按网上一些资料实现了个自旋锁
拿来和 posix 的mutex，spinlock 一起测，结果出乎我意料。
mutex的成绩非常好，我自己实现的稍微差点，posix 的pthread_spinlock_t的结果比较差。
这个真没想到，mutex的效率这么高，看到这个结果我都觉得不相信自己的眼睛了
还是印证了，不要靠自己感觉，实际数据才是最真实的。

谁能解释一下，谢谢~

环境：
uname -a
Linux bsd02 2.6.35.9 #1 SMP Tue Jan 11 02:09:50 EST 2011 x86_64 GNU/Linux
双核 Pentium(R) Dual-Core  CPU      E5400  @ 2.70GHz

并发20个线程测试，结果:
我的实现：
real    0m1.659s
user    0m3.276s
sys     0m0.000s

mutex：
real    0m1.481s
user    0m1.164s
sys     0m1.764s

pthread spinlock:
real    0m6.171s
user    0m12.301s
sys     0m0.004s

int-main

spinlock有这么差吗？是不是没用对

ydfgic

这是最原始版本的代码，最终代码1楼以更新
======
附上代码:

1. #ifndef MY_SPINLOCK_H
   
2. #define MY_SPINLOCK_H
   
3. 
   
4. #include<stdint.h>
   
5. 
   
6. typedef volatile uint32_t my_spinlock_t;
   
7. 
   
8. #define MY_SPINLOCK_INITIALIZER 0
   
9. #define DELAY_NR 10000
   
10. 
    
11. static uint32_t bar = 13;
    
12. static uint32_t *foo = &bar;
    
13. 
    
14. #define my_spinlock_lock(lock) do{  \
    
15.     int i;  \
    
16.     while(!__sync_bool_compare_and_swap(lock, 0, 1))    \
    
17.     {   \
    
18.         i = 0;  \
    
19.         while(i++ < DELAY_NR)   \
    
20.             *foo = (*foo * 33) + 17;    \
    
21.     }   \
    
22. }while(0)
    
23. 
    
24. #define my_spinlock_unlock(lock) do{    \
    
25.     *lock = 0;  \
    
26. }while(0)
    
27. 
    
28. 
    
29. #endif

复制代码

1. #include"myspinlock.h"
   
2. my_spinlock_t lock =  MY_SPINLOCK_INITIALIZER;
   
3. volatile int cnt = 0;
   
4. 
   
5. #include<pthread.h>
   
6. #include<stdio.h>
   
7. // gcc -Wall -g -o myspinlock.out myspinlock.c -lpthread
   
8. 
   
9. #define  NR 1000000
   
10. 
    
11. void * fun1(void * arg)
    
12. {
    
13.     int i = 0, id = *(int*)arg;
    
14.     printf("thread:%d\n",id);
    
15.     for(; i < NR; i++)
    
16.     {
    
17.         my_spinlock_lock(&lock);
    
18.         cnt++;
    
19.         my_spinlock_unlock(&lock);
    
20.     }
    
21.     printf("thread:%d over, lock:%d\n",id, lock);
    
22.     return 0;
    
23. }
    
24. 
    
25. pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;
    
26. 
    
27. void * fun2(void * arg)
    
28. {
    
29.     int i = 0, id = *(int*)arg;
    
30.     printf("thread:%d\n",id);
    
31.     for(; i < NR; i++)
    
32.     {
    
33.         pthread_mutex_lock(&mlock);
    
34.         cnt++;
    
35.         pthread_mutex_unlock(&mlock);
    
36.     }
    
37.     printf("thread:%d over, lock:%d\n",id, lock);
    
38.     return 0;
    
39. }
    
40. pthread_spinlock_t splock;
    
41. 
    
42. void * fun3(void * arg)
    
43. {
    
44.     int i = 0, id = *(int*)arg;
    
45.     printf("thread:%d\n",id);
    
46.     for(; i < NR; i++)
    
47.     {
    
48.         pthread_spin_lock(&splock);
    
49.         cnt++;
    
50.         pthread_spin_unlock(&splock);
    
51.     }
    
52.     printf("thread:%d over, lock:%d\n",id, lock);
    
53.     return 0;
    
54. }
    
55. 
    
56. int N = 20;
    
57. int main(int c, char * s[])
    
58. {
    
59.     pthread_t id[N];
    
60.     int args[N];
    
61.     int i = 0;
    
62.     void * (*fun[])(void*) = { fun1,fun2,fun3};
    
63.     if(--c > 2) c = 0;
    
64.     printf("c:%d\n",c);
    
65.     pthread_spin_init(&splock,0);
    
66. 
    
67.     for(;i<N;++i){
    
68.         args[i] = i;
    
69.         pthread_create(&id[i],NULL,fun[c],&args[i]);
    
70.     }
    
71. 
    
72.     for(i=0;i<N;++i){
    
73.         printf("join thread:%d\n", i);
    
74.         pthread_join(id[i],NULL);
    
75.         printf("join thread:%d done\n", i);
    
76.     }
    
77. 
    
78.     printf("%d\n",cnt);
    
79.     return 0;
    
80. }

复制代码

ydfgic

回复 2# int-main
我贴代码了。
spinlock真的很差，这是个奇迹，它就是发生了。

deadlylight

最关键的__sync_bool_compare_and_swap是什么

你这是每次都lock成功的例子，测试结果没代表性

群雄逐鹿中原

spin lock， 翻译自选锁不好，要翻译成 “忙等锁”，
忙等，必然用在非常变态的场合。

ydfgic

最关键的__sync_bool_compare_and_swap是什么

你这是每次都lock成功的例子，测试结果没代表性
deadlylight 发表于 2011-07-29 11:58

    __sync_bool_compare_and_swap  是 GCC 内建的原子操作函数， 执行CAS 操作，也就是 比较如果相等就swap，并且返回true，否则返回false。所以失败的线程都会进入while循环里去，忙等。

还有个你注意到没，posix 的spinlock效率还低下些。

ydfgic

spin lock， 翻译自选锁不好，要翻译成 “忙等锁”，
忙等，必然用在非常变态的场合。
群雄逐鹿中原 发表于 2011-07-29 13:05

    我觉得我在这里测试的情况也属于变态，呵呵，就是一个 计数累加 就放锁了，按常规逻辑，这就是用spinlock的场景，防止线程陷落到内核态，应该效率比mutex高很多。但是事实却相反...所以很不解啊

群雄逐鹿中原

回复 8# ydfgic


    你的线程，在 while(i++ < DELAY_NR)  时，
被切换掉，然后另一个线程开始自旋，不是要等出人命？

ydfgic

回复 9# 群雄逐鹿中原


    好像自旋锁是这个概念吧，不放cpu在那里忙等，我已经调整了DELAY_NR的值了
网上还有个变态的版本就是 while(*lock);  我试过了效率要低些。