《多处理器编程的艺术》读书笔记（3）--- 双线程解决方案

      我们先从两个虽然存在不足但却十分有趣的锁算法讲起。
      LockOne类
      双线程的锁算法遵循以下两点约定：线程的标识为0或1，若当前调用者的标识为i，则另一方为j = 1 - i；每个线程通过调用ThreadID.get()获取自己的标识。
用write _A(x = v)表示A将值v赋予域x，用read _A(v == x)表示A从域x中读取值v。在值不重要的情形下，可以省略v。下图的write _A(flag[i] = true)事件是由lock()方法中第9行代码的执行所引起的。

Code
 1 class LockOne : ILock
 2 {
 3     private volatile bool[] flag = new bool[2];
 4 
 5     public void setlock()
 6     {
 7         int i = ThreadID.get();
 8         int j = 1 - i;
 9         flag[i] = true;
10         while (flag[j]) { }       //wait
11     }
12 
13     public void unlock()
14     {
15         int i = ThreadID.get();
16         flag[i] = false;
17     }
18 }

      LockOne算法虽然满足互斥特性，但存在着缺陷，其原因在于线程交叉执行时会出现死锁。若事件write _A(flag[A] = true)及write _B(flag[B] = true)在事件read _A(flag[B])和read _B(flag[A])之前发生，那么两个线程都将陷入无穷等待。然而，LockOne算法有一个有趣的特点：如果一个线程在另一个线程之前运行，则不会发生死锁，一切都工作得很好。

LockTwo类

Code
 1 class LockTwo : ILock
 2 {
 3     private volatile int victim;
 4 
 5     public void setlock()
 6     {
 7         int i = ThreadID.get();
 8         victim = i;
 9         while (victim == i) { }    //wait
10     }
11 
12     public void unlock() { }
13 }

      LockTwo类也存在缺陷，当一个线程完全先于另一个线程就会出现死锁。但是如果线程并发地执行时，setlock()方法则是成功的。LockOne类和LockTwo类彼此互补：能够保证一种解法正常工作的条件将会使另一种解法发生死锁。

Peterson锁
      该算法将LockOne和LockTwo结合起来，无疑是最简洁、最完美的双线程互斥算法，按照其发明者的名字被命名为“Peterson算法”。

Code
 1 class Peterson : ILock
 2 {
 3     private volatile bool[] flag = new bool[2];
 4     private volatile int victim;
 5 
 6     public void setlock()
 7     {
 8         int i = ThreadID.get();
 9         int j = 1 - i;
10         flag[i] = true;
11         victim = i;
12         while (flag[j] && victim == i) { }    //wait
13     }
14 
15     public void unlock()
16     {
17         int i = ThreadID.get();
18         flag[i] = false;
19     }
20 }

转载于:https://www.cnblogs.com/pennant/archive/2009/09/30/1577025.html