《多处理器编程的艺术》读书笔记（4） 自旋锁（1）

    任何互斥协议都会产生这样的问题：如果不能获得锁，应该怎么做？对此有两种选择。其一种方案是让其继续进行尝试，这种锁称为自旋锁，对锁的反复测试过程称为旋转或忙等待。在希望锁延迟较短的情形下，选择旋转的方式比较合乎情理。但只有在多处理器中旋转才有实际意义。

TASLock 

 1 public class TASLock : ILock
 2 {
 3     private const int WAITING = 0;
 4     private const int EXECUTING = 1;
 5     int state = WAITING;
 6 
 7     public void setLock()
 8     {
 9         while (Interlocked.CompareExchange(ref state, EXECUTING, WAITING) == EXECUTING)
10         {
11 
12         }
13     }
14 
15     public void unlock()
16     {
17         Interlocked.Exchange(ref state, WAITING);
18     }
19 }

TTASLock

 1 public class TTASLock : ILock
 2 {
 3     private const int WAITING = 0;
 4     private const int EXECUTING = 1;
 5     int state = WAITING;
 6 
 7     public void setLock()
 8     {
 9         while (true)
10         {
11             while (state == EXECUTING) { }
12             if (Interlocked.CompareExchange(ref state, EXECUTING, WAITING) == WAITING)
13             {
14                 return;
15             }
16         }
17     }
18 
19     public void unlock()
20     {
21         Interlocked.Exchange(ref state, WAITING);
22     }
23 }

    从正确性的角度来看，TASLock和TTASLock算法是等价的：每一个算法都保证了无死锁的互斥。（原书中算法都是Java代码，使用AtomicBoolean类实现，这里修改为C#代码，不知道和原Java代码意图的差别有多大）但在测试中发现TTASLock比TASLock性能要好，并且性能更稳定。（没有用正式测试软件测试，不会用，请高人指点指点，这里只是本人DEBUG N次的感觉）

    性能的差距就是在 state == EXECUTING，每个处理器都有一个cache，它是一种高速的小容量存储器，用来存放处理器感兴趣的数据。对内存的访问通常要比对cache的访问多出几个数量级的机器周期。所以cache的性能对于多处理器系统结构的整体性能具有至关重要的影响。当处理器从内存地址中读数据时，首先检查该地址及其所有存储的数据是否已在它的cache中。如果在cache中，那么处理器产生一个cache命中，并可以立即加载这个值。如果不在，则产生一个cache缺失，且必须在内存或另一个处理器的cache中查找这个数据。接着，处理器在总线上广播这个地址，其它的处理器监听总线。如果某个处理器在自己的cache中发现这个地址，则广播该地址及其值来做出响应。如果所有处理器中都没有发现此地址，则以内存中该地址所对应的值来进行响应。