linux锁机制：ticket spinlock
spinlock
spinlock即自旋锁，在linux内核中广泛运用的底层同步机制，相对于可睡眠锁，spinlock采用spin的方式获取锁（busy-wait），
避免了context_switch的开销，在短暂临界区访问场景下速度明显提升，性能更高，对memory等critical section互斥访问，发挥着重要作用。
spinlock对内核的数据安全性和并发性能有很大的影响。这些年来，内核开发者在自旋锁的实现上做了大量优化工作。
早期内核下，如linux2.6.24，自旋锁spinlock用一个整数值来表示，表明了锁是否可用，初值设为1。
spin_lock()函数通过递减val（原子方式），然后查看是否为0，若为0则成功拿锁，若为负数则代表锁已属于他人，所以它进入spin状态，不断查询val值直到变为1。当锁的拥有者完成critical section的执行，将val置为1，即释放锁。
显而易见，这种方式拿锁非常快，尤其是当没有锁竞争的时候，性能非常不错。不过这种方法有一个缺点：它是不公平的。
何为不公平？
当锁的onwer释放锁后，锁的等待者需要发起竞争，这种机制没有办法保证等待时间最长的CPU能优先获得锁，并且激烈的竞争增加了额外的总线开销。
事实上，刚刚释放锁的那个处理器，由于拥有高速缓存原因，很大概率会优先拿到锁，同样无法保证锁的公平性，所以某些场景下spinlock会带来性能损失、实时性降低。
所以在该机制下，我们很难确保一个CPU从申请拿锁到真实获取锁的延迟时间，极端情况下，拿锁的时间可能是任意长。某些高要求实时性的业务场景是不能容忍的。
举个生活中的例子：
spinlock好比火车上上厕所，很多人同时竞争一个厕所，而恰巧你吃了不干净的东西，很捉急，若没有公平性，后果是灾难性的。
ticket机制
来到主题，为解决上述问题，内核引入ticket spinlock，解决了不公平问题，它是如何做到的？
再举个例子：去过银行都知道，办业务先取张票，票上面有一个编号，每新来一个客户编号会加1，银行显示屏上会显示当前正服务的客户编号。
当有多位客户等待时，银行按照编号顺序来对其进行服务。由此，实现了公平性，这类似于FIFO算法。
ticket spinlock就是采用了这种机制，spinlock的val变量被分割成2部分：
next是发票机最后发出的编号，而owner是正在被服务的编号。
typedef struct {
union {
atomic_t val;
struct __raw_tickets {
u16 next;
u16 owner;
} tickets;
};
} arch_spinlock_t;ticket spinlock伪代码实现：
//加锁
spin_lock(lock *l)
{
int n = atomic_add(1, l.next); //先拿票
while(n != atomic_read(l.owner) + 1) //查看是否轮到自己
cpu_relax();
}
//放锁
spin_unlock(lock *l)
{
atomic_add(1, l.owner); //服务完成，叫下一号
}
假设有8个线程同时竞争锁，如下示例：now_serving代表正在持锁的线程，next_ticket代表最后到来的线程，各线程会按顺序进行拿锁。
now_serving next_ticket
| |
V V
... 0 1 2 3 4 5 6 7 8 9 10 ...
\_________/
8 threads
holding one ticket each
linux arm32中spinlock实现：
/*
* ARMv6 ticket-based spin-locking.
*
* A memory barrier is required after we get a lock, and before we
* release it, because V6 CPUs are assumed to have weakly ordered
* memory.
*/
static inline void arch_spin_lock(arch_spinlock_t *lock)
{
unsigned long tmp;
u32 newval;
arch_spinlock_t lockval;
prefetchw(&lock->slock);
__asm__ __volatile__(
"1: ldrex %0, [%3]\n" /* 原子方式，读取锁的值赋值给lockval */
" add %1, %0, %4\n" /* 将next字段++之后的值存在newval中 */
" strex %2, %1, [%3]\n" /* 原子方式，将新的值存在lock中，写入否成功结果存入在tmp中 */
" teq %2, #0\n" /* 判断是否写入成功，不成功跳到标号1重新执行 */
" bne 1b"
: "=&r" (lockval), "=&r" (newval), "=&r" (tmp)
: "r" (&lock->slock), "I" (1 << TICKET_SHIFT)
: "cc");
/* 查询是否可以拿锁，若next != owner说明已有人持锁，自旋 */
while (lockval.tickets.next != lockval.tickets.owner) {
wfe();
lockval.tickets.owner = READ_ONCE(lock->tickets.owner);
}
smp_mb();
}
/* 释放锁比较简单，将owner++即可 */
static inline void arch_spin_unlock(arch_spinlock_t *lock)
{
smp_mb();
lock->tickets.owner++;
dsb_sev();
}
总结：
ticket spinlock自旋锁出现之前，所有处理器争夺一个锁先看谁能抢到它。现在他们排队等好，获取锁的顺序到达。
虽然ticket spinlock看起来很cool，但已然是过去时了，在较高版本内核版本中spinlock再次变身，升级为queued spinlock，这将带来更大的性能提升。