自旋锁是用于保护短的代码片段，其中只包含少量C语句，因此会很快执行完毕。大多数内核数据结构都有自身的自旋锁，在处理结构中的关键成员时，必须获得相应的自旋锁。

定义自旋锁

struct task_struct {
     ...
     /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
     spinlock_t alloc_lock;
     ...

1757 /*                                                                          
1758  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring           
1759  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
1760  * pins the final release of task.io_context.  Also protects ->cpuset and    
1761  * ->cgroup.subsys[].                                                      
1762  *                                                                                                              
1763  * Nests both inside and outside of read_lock(&tasklist_lock).         
1764  * It must not be nested with write_lock_irq(&tasklist_lock),                                  
1765  * neither inside nor outside.                                   
1766  */ 

初始化自旋锁

./kernel/fork.c:1049:    spin_lock_init(&p->alloc_lock);

获取自旋锁

1767 static inline void task_lock(struct task_struct *p)              
1768 {                                                                 
1769     spin_lock(&p->alloc_lock);                                      
1770 }    

释放自旋锁

1772 static inline void task_unlock(struct task_struct *p)          
1773 {                                                              
1774     spin_unlock(&p->alloc_lock);           
1775 }

自旋锁的使用

在处理 task_struct 结构中的 ptrace / files / active_mm / mm / flags / cgroups / io_context 等关键成员时，需要获取 alloc_lock 自旋锁。

void foo()
{
    task_lock(current);
    // 处理 task_struct 结构的关键成员
    task_unlock(current);
}

为什么这么多关键成员都使用同一个 alloc_lock 自旋锁呢？ 不会影响性能吗？ 为什么不使用不同的自旋锁呢？
个人理解：因为使用 alloc_lock 所保护的关键成员操作并不频繁，而且操作的时间点并不集中，所以不会影响性能。

自旋锁用来在多处理器的环境下保护数据。如果内核发现数据未锁，就获取锁并运行；如果数据已锁，就一直旋转，其实是一直反复执行一条指令。之所以说自旋锁用在多处理器环境，是因为在单处理器环境（非抢占式内核）下，自旋锁其实不起作用。在单处理器抢占式内核的情况下，自旋锁起到禁止抢占的作用。
因为被自旋锁锁着的进程一直旋转，而不是睡眠，所以自旋锁可以用在中断等禁止睡眠的场景。

spin_lock 会考虑下面两种情况：

• 如果内核中其他地方尚未获得 lock，则有当前处理器获取。其它处理器不能再进入 lock 保护的代码范围。
• 如果 lock 已经由另一个处理器获得，spin_lock 进入一个无限循环，重复地检查 lock 是否已经由 spin_unlock 释放（自旋锁因此得名）。如果已经释放，则获得 lock ，并进入临界区。

在使用自旋锁时必须要注意下面两点。

• 如果获得锁之后不释放，系统将变的不可用。所有的处理器（包括获得锁的在内），迟早需要进入对应的临界区。它们会进入无限循环等待锁释放，但等不到。便产生了死锁。
• 自旋锁绝不应该长期持有，因为所有等待释放锁的处理器都处于不可用状态，无法用于其他工作（信号量的情形有所不同）。