谁能解释一下，自旋锁spinlock

Alligator27

spinlock 用于CPU同步, 它的实现是基于CPU锁定数据总线的指令.
当某个CPU锁住数据总线后, 它读一个内存单元(spinlock_t)来判断这个spinlock 是否已经被别的CPU锁住. 如果否, 它写进一个特定值, 表示锁定成功, 然后返回. 如果是, 它会重复以上操作直到成功, 或者spin次数超过一个设定值. 锁定数据总线的指令只能保证一个机器指令内, CPU独占数据总线.
单CPU当然能用spinlock, 但实现上无需锁定数据总线.

Alligator27

原帖由 柳五随风 于 2005-11-2 23:04 发表
spinlock在锁定的时候,如果不成功,不会睡眠,会持续的尝试,单cpu的时候spinlock会让其它process动不了.

一般spinlock实现会有一个参数限定最多持续尝试次数. 超出后, spinlock放弃当前time slice. 等下一次机会.

Alligator27

原帖由 lenovo 于 2005-11-2 23:11 发表
在书上抄的，我也不懂。

自旋锁是一种保护数据结构或代码片段的原始方式，
在某个时刻只允许一个进程访问临界区内的代码。

用户空间, 应当是进程内只允许一个线程访问临界区内的代码.
内核进程共享地址空间, 进程之间互斥是没错.

Alligator27

原帖由 bleem1998 于 2005-11-3 08:24 发表
有三果问题不清楚
1，单CPU内核中，假设好几个内核线程用spinlock共享一块数据，一个时间只有一个线程得到锁，那是不是其它没有得到锁的线程都在疯狂的自旋中？

2，内核里似乎到处都有spinlock，在单CPU系统下 ...

1. Yes. 但spinlock只适用于short lock.

2. 单CPU, 或SMP, 都是同步锁

3. Yes

Alligator27

原帖由 帅绝人寰 于 2005-11-3 22:08 发表

前边有的说话不是十分确切。补充一下。

spin的意思，就是自旋、旋转。意思是说，如果加锁操作不成功，CPU就一直在spinning旋转，直到成功加锁为止。很显然，用户态不存在自旋锁，否则OS就乱套了。
大体上， ...

楼上说 "很显然，用户态不存在自旋锁，否则OS就乱套了". 是OS不准许用户用自旋锁吗? 还是用户用了自旋锁OS就乱套?

Alligator27

原帖由 帅绝人寰 于 2005-11-3 22:30 发表


OS不可能提供如此之大的权限给用户程序，因为如果这样，我可以非常简单的在用户层制造死锁事件。

死锁用户程序? 还是死锁OS?

Alligator27

OK. 如果你们有Linux/i386, 试一试这个程序. 我们再接着讨论.

1. 
   
2. 
   
3. #include <pthread.h>
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <unistd.h>
   
7. 
   
8. 
   
9. long
   
10. __attribute__ ((__unused__))
    
11. InterlockedExchange(long* ipLong, long iNewVal)
    
12. {
    
13.         register long __result;
    
14.         __asm__ __volatile__ ("lock; xchgl %0,%2"
    
15.                                                         : "=r" (__result)
    
16.                                                         : "0" (iNewVal), "m" (*ipLong)
    
17.                                                         : "memory");
    
18.         return __result;
    
19. }
    
20. 
    
21. 
    
22. typedef long spinlock_t;
    
23. 
    
24. #define MAX_SPIN 500
    
25. #define UNLOCKED 1
    
26. #define LOCKED   0
    
27. 
    
28. class SpinLock
    
29. {
    
30. public:
    
31.         SpinLock() { mLock=UNLOCKED; }
    
32.         ~SpinLock() {}
    
33. 
    
34.         void Lock();
    
35.         void Unlock() { InterlockedExchange(&mLock, UNLOCKED); }
    
36. 
    
37. private:
    
38.         spinlock_t mLock;
    
39. };
    
40. 
    
41. void SpinLock::Lock()
    
42. {
    
43.         while (1)
    
44.         {
    
45.                 for(int count=0; count<MAX_SPIN; count++)
    
46.                 {
    
47.                         if(InterlockedExchange(&mLock, LOCKED) != LOCKED)
    
48.                                 return;
    
49.                 }
    
50.                 ::sched_yield();
    
51.         }
    
52. }
    
53. 
    
54. int main()
    
55. {
    
56.         int rc=0;
    
57. 
    
58.         SpinLock aLock;
    
59. 
    
60.         // Get lock
    
61.         aLock.Lock();
    
62. 
    
63.         // Release lock
    
64.         aLock.Unlock();
    
65. 
    
66.         // dead lock
    
67.         aLock.Lock();
    
68.         aLock.Lock();
    
69.        
    
70. 
    
71.         /**********************************************************************
    
72.         ** I will never get this far.
    
73.         **********************************************************************/
    
74.         return rc;
    
75. }
    
76. 
    
77. > g++ -m32 foo.cpp
    
78. > a.out
    

复制代码

Alligator27

原帖由 帅绝人寰 于 2005-11-4 11:04 发表
鳄鱼兄，我运行了你的程序，没问题呀，很simply地用Ctrl+C就把程序杀掉了。

我没说有问提啊. 写这个程序是想说. 用户可以有spinlock. 能达到内核一样的互斥, 而且不会锁死系统.

Alligator27

原帖由 帅绝人寰 于 2005-11-4 11:09 发表
LOCK并不是一个独立的指令，它只是一个指令前缀，而且只能作用于紧随其后的那条指令，而非全部。
所以，正在spinning的CPU，还是有能力响应中断的；相反，如果你步步都锁住了总线，那么连中断也无法响应了。

...

为什么要求特权呢? 因为它可能占太多CPU? 你不是试验了, 可以很容易把它踢出来吗.

Alligator27

终于明白了我于帅兄的分歧．我只写用户层的code. 对内核一无所知．

从用户程序的角度来看，spinlock适用于保护非常短的code, 比如几条指令，(象链表操作), 也就是柳五随风提到的闪锁，这比mutex快很多，而且所用资源仅一个寄存器长的内存．它的目的不是要　＂除了中断谁都不响应，而且即使是中断，中断返回时也还是必然返回到自旋的那段代码，继续自旋＂