Java并发与多线程教程(2)

Java同步块

 

 

Java 同步块（synchronized block）用来标记方法或者代码块是同步的。Java同步块用来避免竞争。本文介绍以下内容：

  • Java同步关键字（synchronzied）
  • 同步的实例方法
  • 同步的静态方法
  • 实例方法中的同步块
  • 静态方法中的同步块
  • Java同步示例
  • Java并发工具集

 

Java 同步关键字（synchronized）

Java中的同步块用synchronized标记。同步块在Java中是同步在某个对象上。所有在一个对象上的同步块在同时只能被一个线程进入并执行操作。所有其他等待进入该同步块的线程将被阻塞，直到执行该同步块中的线程退出。

synchronized关键可以用在四种不同的代码块中：

  1. 实例方法
  2. 静态方法
  3. 实例方法中的代码块
  4. 静态方法中的代码块

上述代码块都同步在不同对象上。实际需要哪种同步块视具体情况而定。

同步实例方法

下面是一个同步的实例方法：

 

[java] view plain copy
 
  1. public synchronized void add(int value){  
  2.     this.count += value;  
  3. }  

注意在方法声明中同步（synchronized ）关键字。这告诉Java该方法是同步的。

Java同步实例方法是同步在拥有该方法的对象上。这样，对每个实例其同步方法都同步在不同的对象上，即该方法所属的实例。只有一个线程能够在同步实例方法中运行。如果有多个实例存在，那么每个实例上一次只能有一个线程在同步实例方法中执行操作。一个实例一个线程。

同步静态方法

同步静态方法和同步实例方法一样，也使用synchronized 关键字。Java同步静态方法如下示例：

[java] view plain copy
 
  1. public static synchronized void add(int value){  
  2.     count += value;  
  3. }  

同样，这里synchronized关键字告诉Java这个方法是同步的。

同步静态方法是指同步在该方法所在的类对象上。因为在Java虚拟机中一个类只能对应一个类对象，所以同时只允许一个线程执行同一个类中的静态同步方法。

对于不同类中的静态同步方法，每个类中一次只能有一个线程执行类中的静态同步方法而无需等待。不管类中的哪个静态同步方法被调用，一个类只能由一个线程同时执行。

实例方法中的同步块

有时你不需要同步整个方法，而是同步方法中的一部分。Java可以对方法的一部分进行同步。

在非同步的Java方法中的同步块的例子如下所示：

[java] view plain copy
 
  1. public void add(int value){  
  2.   
  3.   synchronized(this){  
  4.      this.count += value;     
  5.   }  
  6. }  

示例使用Java同步块构造器来标记一块代码是同步的。该代码在执行时和同步方法一样。

注意Java同步块构造器用括号将对象括起来。在上例中，使用了“this”，即为调用add方法的实例本身。在同步构造器中用括号括起来的对象叫做监视器对象。上述代码使用监视器对象同步，同步实例方法使用调用方法本身的实例作为监视器对象。

在一个监视器对象上一次只能有一个线程在同步块内执行。

下面两个例子都同步在他们所调用的实例对象上，因此他们在同步的执行效果上是等效的。

 

[java] view plain copy
 
  1. public class MyClass {  
  2.   
  3.   public synchronized void log1(String msg1, String msg2){  
  4.      log.writeln(msg1);  
  5.      log.writeln(msg2);  
  6.   }  
  7.   
  8.   
  9.   public void log2(String msg1, String msg2){  
  10.      synchronized(this){  
  11.         log.writeln(msg1);  
  12.         log.writeln(msg2);  
  13.      }  
  14.   }  
  15. }  

 

在上例中，每次只能有一个线程能够在两个同步块中的任意一个内执行。

如果第二个同步块不是同步在this实例对象上，那么两个方法可以被一个线程同时执行。

静态方法中的同步块

和上面类似，下面是两个静态方法同步的例子。这些方法同步在该方法所属的类对象上。

[java] view plain copy
 
  1. public class MyClass {  
  2.   
  3.   public static synchronized void log1(String msg1, String msg2){  
  4.      log.writeln(msg1);  
  5.      log.writeln(msg2);  
  6.   }  
  7.   
  8.   
  9.   public static void log2(String msg1, String msg2){  
  10.      synchronized(MyClass.class){  
  11.         log.writeln(msg1);  
  12.         log.writeln(msg2);    
  13.      }  
  14.   }  
  15. }  

这两个方法不允许同时被一个线程访问。

如果第二个同步块不是同步在MyClass.class这个对象上。那么这两个方法可以同时被一个线程访问。

Java同步实例

在下面例子中，启动了两个线程，都调用Counter类的同一个add方法。因为同步在该方法所属的实例上，所以同时只能有一个线程访问该方法。

[java] view plain copy
 
  1. public class Counter{  
  2.      
  3.    long count = 0;  
  4.     
  5.    public synchronized void add(long value){  
  6.      this.count += value;  
  7.    }  
  8. }  
[java] view plain copy
 
  1.  public class CounterThread extends Thread{  
  2.   
  3.     protected Counter counter = null;  
  4.   
  5.     public CounterThread(Counter counter){  
  6.        this.counter = counter;  
  7.     }  
  8.   
  9.     public void run() {  
  10. for(int i=0; i<10; i++){  
  11.           counter.add(i);  
  12.        }  
  13.     }  
  14.  }  
[java] view plain copy
 
  1. public class Example {  
  2.   
  3.   public static void main(String[] args){  
  4.     Counter counter = new Counter();  
  5.     Thread  threadA = new CounterThread(counter);  
  6.     Thread  threadB = new CounterThread(counter);  
  7.   
  8.     threadA.start();  
  9.     threadB.start();   
  10.   }  
  11. }  

创建了两个线程。他们的构造器引用同一个Counter实例。Counter.add方法是同步在实例上，是因为add方法是实例方法并且被标记上synchronized关键字。因此每次只允许一个线程调用该方法。另外一个线程必须要等到第一个线程退出add()方法时，才能继续执行方法。

如果两个线程引用了两个不同的Counter实例，那么他们可以同时调用add()方法。这些方法调用了不同的对象，因此这些方法也就同步在不同的对象上。这些方法调用将不会被阻塞。如下面这个例子所示：

[java] view plain copy
 
  1. public class Example {  
  2.   
  3.   public static void main(String[] args){  
  4.     Counter counterA = new Counter();  
  5.     Counter counterB = new Counter();  
  6.     Thread  threadA = new CounterThread(counterA);  
  7.     Thread  threadB = new CounterThread(counterB);  
  8.   
  9.     threadA.start();  
  10.     threadB.start();   
  11.   }  
  12. }  

注意这两个线程，threadA和threadB，不再引用同一个counter实例。CounterA和counterB的add方法同步在他们所属的对象上。调用counterA的add方法将不会阻塞调用counterB的add方法。
Java并发工具集
synchronized机制是Java中对多个线程共享的对象进行同步访问的第一个机制。synchronized机制并不很高级。因此Java 5中引入了一组并发工具集API，以帮助开发实现更好的并发控制。

 

 

线程通信

 

 

 

线程通信的目标是使线程间能够互相发送信号。另一方面，线程通信使线程能够等待其他线程的信号。

例如，线程B可以等待线程A的一个信号，这个信号会通知线程B数据已经准备好了。本文将讲解以下几个JAVA线程间通信的主题：

1、通过共享对象通信

2、忙等待

3、wait(),notify()和notifyAll()

4、丢失的信号

5、假唤醒

6、多线程等待相同信号

7、不要对常量字符串或全局对象调用wait()

1、通过共享对象通信

线程间发送信号的一个简单方式是在共享对象的变量里设置信号值。线程A在一个同步块里设置boolean型成员变量hasDataToProcess为true，线程B也在同步块里读取hasDataToProcess这个成员变量。这个简单的例子使用了一个持有信号的对象，并提供了set和check方法:

[java] view plain copy
 
  1. public class MySignal{  
  2.   
  3.   protected boolean hasDataToProcess = false;  
  4.   
  5.   public synchronized boolean hasDataToProcess(){  
  6.     return this.hasDataToProcess;  
  7.   }  
  8.   
  9.   public synchronized void setHasDataToProcess(boolean hasData){  
  10.     this.hasDataToProcess = hasData;    
  11.   }  
  12.   
  13. }  

线程A和B必须获得指向一个MySignal共享实例的引用，以便进行通信。如果它们持有的引用指向不同的MySingal实例，那么彼此将不能检测到对方的信号。需要处理的数据可以存放在一个共享缓存区里，它和MySignal实例是分开存放的。

2、忙等待(Busy Wait)

准备处理数据的线程B正在等待数据变为可用。换句话说，它在等待线程A的一个信号，这个信号使hasDataToProcess()返回true。线程B运行在一个循环里，以等待这个信号：

[java] view plain copy
 
  1. protected MySignal sharedSignal = ...  
  2.   
  3. ...  
  4.   
  5. while(!sharedSignal.hasDataToProcess()){  
  6.   //do nothing... busy waiting  
  7. }  

3、wait(),notify()和notifyAll()

忙等待没有对运行等待线程的CPU进行有效的利用，除非平均等待时间非常短。否则，让等待线程进入睡眠或者非运行状态更为明智，直到它接收到它等待的信号。

Java有一个内建的等待机制来允许线程在等待信号的时候变为非运行状态。java.lang.Object 类定义了三个方法，wait()、notify()和notifyAll()来实现这个等待机制。

一个线程一旦调用了任意对象的wait()方法，就会变为非运行状态，直到另一个线程调用了同一个对象的notify()方法。为了调用wait()或者notify()，线程必须先获得那个对象的锁。也就是说，线程必须在同步块里调用wait()或者notify()。以下是MySingal的修改版本——使用了wait()和notify()的MyWaitNotify：

[java] view plain copy
 
  1. public class MonitorObject{  
  2. }  
  3.   
  4. public class MyWaitNotify{  
  5.   
  6.   MonitorObject myMonitorObject = new MonitorObject();  
  7.   
  8.   public void doWait(){  
  9.     synchronized(myMonitorObject){  
  10.       try{  
  11.         myMonitorObject.wait();  
  12.       } catch(InterruptedException e){...}  
  13.     }  
  14.   }  
  15.   
  16.   public void doNotify(){  
  17.     synchronized(myMonitorObject){  
  18.       myMonitorObject.notify();  
  19.     }  
  20.   }  
  21. }  

等待线程将调用doWait()，而唤醒线程将调用doNotify()。当一个线程调用一个对象的notify()方法，正在等待该对象的所有线程中将有一个线程被唤醒并允许执行（校注：这个将被唤醒的线程是随机的，不可以指定唤醒哪个线程）。同时也提供了一个notifyAll()方法来唤醒正在等待一个给定对象的所有线程。

如你所见，不管是等待线程还是唤醒线程都在同步块里调用wait()和notify()。这是强制性的！一个线程如果没有持有对象锁，将不能调用wait()，notify()或者notifyAll()。如果调用了，会抛出IllegalMonitorStateException异常。

（校注：JVM是这么实现的，当你调用wait时候它首先要检查下当前线程是否是锁的拥有者，不是则抛出IllegalMonitorStateExcept，参考JVM源码的 1422行。）

但是，这怎么可能？等待线程在同步块里面执行的时候，不是一直持有监视器对象（myMonitor对象）的锁吗？等待线程不能阻止唤醒线程进入doNotify()的同步块吗？答案是：的确不能。一旦线程调用了wait()方法，它就释放了所持有的监视器对象上的锁。这将允许其他线程也可以调用wait()或者notify()。

一旦一个线程被唤醒，不能立刻就退出wait()的方法调用，直到调用notify()的线程退出了它自己的同步块。换句话说：被唤醒的线程必须重新获得监视器对象的锁，才可以退出wait()的方法调用，因为wait方法调用运行在同步块里面。如果多个线程被notifyAll()唤醒，那么在同一时刻将只有一个线程可以退出wait()方法，因为每个线程在退出wait()前必须获得监视器对象的锁。

4、丢失的信号（Missed Signals）

notify()和notifyAll()方法不会保存调用它们的方法，因为当这两个方法被调用时，有可能没有线程处于等待状态。通知信号过后便丢弃了。因此，如果一个线程先于被通知线程调用wait()前调用了notify()，等待的线程将错过这个信号。这可能是也可能不是个问题。不过，在某些情况下，这可能使等待线程永远在等待，不再醒来，因为线程错过了唤醒信号。
为了避免丢失信号，必须把它们保存在信号类里。在MyWaitNotify的例子中，通知信号应被存储在MyWaitNotify实例的一个成员变量里。以下是MyWaitNotify的修改版本：

[java] view plain copy
 
  1. public class MyWaitNotify2{  
  2.   
  3.   MonitorObject myMonitorObject = new MonitorObject();  
  4.   boolean wasSignalled = false;  
  5.   
  6.   public void doWait(){  
  7.     synchronized(myMonitorObject){  
  8.       if(!wasSignalled){  
  9.         try{  
  10.           myMonitorObject.wait();  
  11.          } catch(InterruptedException e){...}  
  12.       }  
  13.       //clear signal and continue running.  
  14.       wasSignalled = false;  
  15.     }  
  16.   }  
  17.   
  18.   public void doNotify(){  
  19.     synchronized(myMonitorObject){  
  20.       wasSignalled = true;  
  21.       myMonitorObject.notify();  
  22.     }  
  23.   }  
  24. }  

留意doNotify()方法在调用notify()前把wasSignalled变量设为true。同时，留意doWait()方法在调用wait()前会检查wasSignalled变量。事实上，如果没有信号在前一次doWait()调用和这次doWait()调用之间的时间段里被接收到，它将只调用wait()。

（校注：为了避免信号丢失， 用一个变量来保存是否被通知过。在notify前，设置自己已经被通知过。在wait后，设置自己没有被通知过，需要等待通知。）

5、假唤醒

由于莫名其妙的原因，线程有可能在没有调用过notify()和notifyAll()的情况下醒来。这就是所谓的假唤醒（spurious wakeups）。无端端地醒过来了。

如果在MyWaitNotify2的doWait()方法里发生了假唤醒，等待线程即使没有收到正确的信号，也能够执行后续的操作。这可能导致你的应用程序出现严重问题。

为了防止假唤醒，保存信号的成员变量将在一个while循环里接受检查，而不是在if表达式里。这样的一个while循环叫做自旋锁（校注：这种做法要慎重，目前的JVM实现自旋会消耗CPU，如果长时间不调用doNotify方法，doWait方法会一直自旋，CPU会消耗太大）。被唤醒的线程会自旋直到自旋锁(while循环)里的条件变为false。以下MyWaitNotify2的修改版本展示了这点：

[java] view plain copy
 
  1. public class MyWaitNotify3{  
  2.   
  3.   MonitorObject myMonitorObject = new MonitorObject();  
  4.   boolean wasSignalled = false;  
  5.   
  6.   public void doWait(){  
  7.     synchronized(myMonitorObject){  
  8.       while(!wasSignalled){  
  9.         try{  
  10.           myMonitorObject.wait();  
  11.          } catch(InterruptedException e){...}  
  12.       }  
  13.       //clear signal and continue running.  
  14.       wasSignalled = false;  
  15.     }  
  16.   }  
  17.   
  18.   public void doNotify(){  
  19.     synchronized(myMonitorObject){  
  20.       wasSignalled = true;  
  21.       myMonitorObject.notify();  
  22.     }  
  23.   }  
  24. }  

留意wait()方法是在while循环里，而不在if表达式里。如果等待线程没有收到信号就唤醒，wasSignalled变量将变为false,while循环会再执行一次，促使醒来的线程回到等待状态。

6、多个线程等待相同信号

如果你有多个线程在等待，被notifyAll()唤醒，但只有一个被允许继续执行，使用while循环也是个好方法。每次只有一个线程可以获得监视器对象锁，意味着只有一个线程可以退出wait()调用并清除wasSignalled标志（设为false）。一旦这个线程退出doWait()中的同步块，其他线程就可以退出wait()调用，并在while循环里检查wasSignalled变量值。但是，这个标志已经被第一个唤醒的线程清除了，所以其余醒来的线程将回到等待状态，直到下次信号到来。

7、不要在字符串常量或全局对象中调用wait()

（校注：本章说的字符串常量指的是值为常量的字符串变量）

本文早期的一个版本在MyWaitNotify例子里使用字符串常量（””）作为管程对象（即监视器对象）。以下是那个例子：

[java] view plain copy
 
  1. public class MyWaitNotify{  
  2.   
  3.   String myMonitorObject = "";  
  4.   boolean wasSignalled = false;  
  5.   
  6.   public void doWait(){  
  7.     synchronized(myMonitorObject){  
  8.       while(!wasSignalled){  
  9.         try{  
  10.           myMonitorObject.wait();  
  11.          } catch(InterruptedException e){...}  
  12.       }  
  13.       //clear signal and continue running.  
  14.       wasSignalled = false;  
  15.     }  
  16.   }  
  17.   
  18.   public void doNotify(){  
  19.     synchronized(myMonitorObject){  
  20.       wasSignalled = true;  
  21.       myMonitorObject.notify();  
  22.     }  
  23.   }  
  24. }  

在空字符串作为锁的同步块(或者其他常量字符串)里调用wait()和notify()产生的问题是，JVM/编译器内部会把常量字符串转换成同一个对象。这意味着，即使你有2个不同的MyWaitNotify实例，它们都引用了相同的空字符串实例。同时也意味着存在这样的风险：在第一个MyWaitNotify实例上调用doWait()的线程会被在第二个MyWaitNotify实例上调用doNotify()的线程唤醒。这种情况可以画成以下这张图：

起初这可能不像个大问题。毕竟，如果doNotify()在第二个MyWaitNotify实例上被调用，真正发生的事不外乎线程A和B被错误的唤醒了 。这个被唤醒的线程（A或者B）将在while循环里检查信号值，然后回到等待状态，因为doNotify()并没有在第一个MyWaitNotify实例上调用，而这个正是它要等待的实例。这种情况相当于引发了一次假唤醒。线程A或者B在信号值没有更新的情况下唤醒。但是代码处理了这种情况，所以线程回到了等待状态。记住，即使4个线程在相同的共享字符串实例上调用wait()和notify()，doWait()和doNotify()里的信号还会被2个MyWaitNotify实例分别保存。在MyWaitNotify1上的一次doNotify()调用可能唤醒MyWaitNotify2的线程，但是信号值只会保存在MyWaitNotify1里。

问题在于，由于doNotify()仅调用了notify()而不是notifyAll()，即使有4个线程在相同的字符串（空字符串）实例上等待，只能有一个线程被唤醒。所以，如果线程A或B被唤醒但信号是发给C或D的，A或B会检查自己的信号值，看看有没有信号被接收到，然后回到等待状态。而C和D都没被唤醒来检查它们实际上接收到的信号值，这样信号便丢失了。这种情况相当于前面所说的丢失信号的问题。C和D被发送过信号，只是都不能对信号作出回应。

如果doNotify()方法调用notifyAll()，而非notify()，所有等待线程都会被唤醒并依次检查信号值。线程A和B将回到等待状态，但是C或D只有一个线程注意到信号，并退出doWait()方法调用。C或D中的另一个将回到等待状态，因为获得信号的线程在退出doWait()的过程中清除了信号值(置为false)。

看过上面这段后，你可能会设法使用notifyAll()来代替notify()，但是这在性能上是个坏主意。在只有一个线程能对信号进行响应的情况下，没有理由每次都去唤醒所有线程。

所以：在wait()/notify()机制中，不要使用全局对象，字符串常量等。应该使用对应唯一的对象。例如，每一个MyWaitNotify3的实例（前一节的例子）拥有一个属于自己的监视器对象，而不是在空字符串上调用wait()/notify()。

校注：

管程 (英语：Monitors，也称为监视器) 是对多个工作线程实现互斥访问共享资源的对象或模块。这些共享资源一般是硬件设备或一群变量。管程实现了在一个时间点，最多只有一个线程在执行它的某个子程序。与那些通过修改数据结构实现互斥访问的并发程序设计相比，管程很大程度上简化了程序设计。

 

死锁

 

 

死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。

例如，如果线程1锁住了A，然后尝试对B进行加锁，同时线程2已经锁住了B，接着尝试对A进行加锁，这时死锁就发生了。线程1永远得不到B，线程2也永远得不到A，并且它们永远也不会知道发生了这样的事情。为了得到彼此的对象（A和B），它们将永远阻塞下去。这种情况就是一个死锁。

 

该情况如下：

[plain] view plain copy
 
  1. Thread 1  locks A, waits for B  
  2. Thread 2  locks B, waits for A  

这里有一个TreeNode类的例子，它调用了不同实例的synchronized方法：

[java] view plain copy
 
  1. public class TreeNode {  
  2.    
  3.   TreeNode parent   = null;    
  4.   List     children = new ArrayList();  
  5.   
  6.   public synchronized void addChild(TreeNode child){  
  7.     if(!this.children.contains(child)) {  
  8.       this.children.add(child);  
  9.       child.setParentOnly(this);  
  10.     }  
  11.   }  
  12.     
  13.   public synchronized void addChildOnly(TreeNode child){  
  14.     if(!this.children.contains(child){  
  15.       this.children.add(child);  
  16.     }  
  17.   }  
  18.     
  19.   public synchronized void setParent(TreeNode parent){  
  20.     this.parent = parent;  
  21.     parent.addChildOnly(this);  
  22.   }  
  23.   
  24.   public synchronized void setParentOnly(TreeNode parent){  
  25.     this.parent = parent;  
  26.   }  
  27. }  

如果在同一个parent和child对象上，线程1调用parent.addChild(child)方法的同时有另外一个线程2调用child.setParent(parent)方法，此时就会发生死锁。下面的伪代码说明了这个过程：

[plain] view plain copy
 
  1. Thread 1: parent.addChild(child); //locks parent  
  2.           --> child.setParentOnly(parent);  
  3.   
  4. Thread 2: child.setParent(parent); //locks child  
  5.           --> parent.addChildOnly()  

首先线程1调用parent.addChild(child)。因为addChild()是同步的，所以线程1会对parent对象加锁以不让其它线程访问该对象。

然后线程2调用child.setParent(parent)。因为setParent()是同步的，所以线程2会对child对象加锁以不让其它线程访问该对象。

现在child和parent对象被两个不同的线程锁住了。接下来线程1尝试调用child.setParentOnly()方法，但是由于child对象现在被线程2锁住的，所以该调用会被阻塞。线程2也尝试调用parent.addChildOnly()，但是由于parent对象现在被线程1锁住，导致线程2也阻塞在该方法处。现在两个线程都被阻塞并等待着获取另外一个线程所持有的锁。

注意：像上文描述的，这两个线程需要同时调用parent.addChild(child)和child.setParent(parent)方法，并且是同一个parent对象和同一个child对象，才有可能发生死锁。上面的代码可能运行一段时间才会出现死锁。

这些线程需要同时获得锁。举个例子，如果线程1稍微领先线程2，然后成功地锁住了A和B两个对象，那么线程2就会在尝试对B加锁的时候被阻塞，这样死锁就不会发生。因为线程调度通常是不可预测的，因此没有一个办法可以准确预测什么时候死锁会发生，仅仅是可能会发生。

更复杂的死锁

死锁可能不止包含2个线程，这让检测死锁变得更加困难。下面是4个线程发生死锁的例子：

[plain] view plain copy
 
  1. Thread 1  locks A, waits for B  
  2. Thread 2  locks B, waits for C  
  3. Thread 3  locks C, waits for D  
  4. Thread 4  locks D, waits for A  

线程1等待线程2，线程2等待线程3，线程3等待线程4，线程4等待线程1。

数据库的死锁

更加复杂的死锁场景发生在数据库事务中。一个数据库事务可能由多条SQL更新请求组成。当在一个事务中更新一条记录，这条记录就会被锁住避免其他事务的更新请求，直到第一个事务结束。同一个事务中每一个更新请求都可能会锁住一些记录。

当多个事务同时需要对一些相同的记录做更新操作时，就很有可能发生死锁，例如：

[plain] view plain copy
 
  1. Transaction 1, request 1, locks record 1 for update  
  2. Transaction 2, request 1, locks record 2 for update  
  3. Transaction 1, request 2, tries to lock record 2 for update.  
  4. Transaction 2, request 2, tries to lock record 1 for update.  

因为锁发生在不同的请求中，并且对于一个事务来说不可能提前知道所有它需要的锁，因此很难检测和避免数据库事务中的死锁。

 

避免死锁

 

在有些情况下死锁是可以避免的。本文将展示三种用于避免死锁的技术：

  1. 加锁顺序
  2. 加锁时限
  3. 死锁检测

 

加锁顺序

当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。

如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。看下面这个例子：

[plain] view plain copy
 
  1. Thread 1:  
  2.   
  3.   lock A   
  4.   lock B  
  5.   
  6.   
  7. Thread 2:  
  8.   
  9.    wait for A  
  10.    lock C (when A locked)  
  11.   
  12.   
  13. Thread 3:  
  14.   
  15.    wait for A  
  16.    wait for B  
  17.    wait for C  

如果一个线程（比如线程3）需要一些锁，那么它必须按照确定的顺序获取锁。它只有获得了从顺序上排在前面的锁之后，才能获取后面的锁。

例如，线程2和线程3只有在获取了锁A之后才能尝试获取锁C(译者注：获取锁A是获取锁C的必要条件)。因为线程1已经拥有了锁A，所以线程2和3需要一直等到锁A被释放。然后在它们尝试对B或C加锁之前，必须成功地对A加了锁。

按照顺序加锁是一种有效的死锁预防机制。但是，这种方式需要你事先知道所有可能会用到的锁(译者注：并对这些锁做适当的排序)，但总有些时候是无法预知的。

加锁时限

另外一个可以避免死锁的方法是在尝试获取锁的时候加一个超时时间，这也就意味着在尝试获取锁的过程中若超过了这个时限该线程则放弃对该锁请求。若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁，然后等待一段随机的时间再重试。这段随机的等待时间让其它线程有机会尝试获取相同的这些锁，并且让该应用在没有获得锁的时候可以继续运行(译者注：加锁超时后可以先继续运行干点其它事情，再回头来重复之前加锁的逻辑)。

以下是一个例子，展示了两个线程以不同的顺序尝试获取相同的两个锁，在发生超时后回退并重试的场景：

[plain] view plain copy
 
  1. Thread 1 locks A  
  2. Thread 2 locks B  
  3.   
  4. Thread 1 attempts to lock B but is blocked  
  5. Thread 2 attempts to lock A but is blocked  
  6.   
  7. Thread 1's lock attempt on B times out  
  8. Thread 1 backs up and releases A as well  
  9. Thread 1 waits randomly (e.g. 257 millis) before retrying.  
  10.   
  11. Thread 2's lock attempt on A times out  
  12. Thread 2 backs up and releases B as well  
  13. Thread 2 waits randomly (e.g. 43 millis) before retrying.  

在上面的例子中，线程2比线程1早200毫秒进行重试加锁，因此它可以先成功地获取到两个锁。这时，线程1尝试获取锁A并且处于等待状态。当线程2结束时，线程1也可以顺利的获得这两个锁（除非线程2或者其它线程在线程1成功获得两个锁之前又获得其中的一些锁）。

需要注意的是，由于存在锁的超时，所以我们不能认为这种场景就一定是出现了死锁。也可能是因为获得了锁的线程（导致其它线程超时）需要很长的时间去完成它的任务。

此外，如果有非常多的线程同一时间去竞争同一批资源，就算有超时和回退机制，还是可能会导致这些线程重复地尝试但却始终得不到锁。如果只有两个线程，并且重试的超时时间设定为0到500毫秒之间，这种现象可能不会发生，但是如果是10个或20个线程情况就不同了。因为这些线程等待相等的重试时间的概率就高的多（或者非常接近以至于会出现问题）。
(译者注：超时和重试机制是为了避免在同一时间出现的竞争，但是当线程很多时，其中两个或多个线程的超时时间一样或者接近的可能性就会很大，因此就算出现竞争而导致超时后，由于超时时间一样，它们又会同时开始重试，导致新一轮的竞争，带来了新的问题。)

这种机制存在一个问题，在Java中不能对synchronized同步块设置超时时间。你需要创建一个自定义锁，或使用Java5中java.util.concurrent包下的工具。写一个自定义锁类不复杂，但超出了本文的内容。后续的Java并发系列会涵盖自定义锁的内容。

死锁检测

死锁检测是一个更好的死锁预防机制，它主要是针对那些不可能实现按序加锁并且锁超时也不可行的场景。

每当一个线程获得了锁，会在线程和锁相关的数据结构中（map、graph等等）将其记下。除此之外，每当有线程请求锁，也需要记录在这个数据结构中。

当一个线程请求锁失败时，这个线程可以遍历锁的关系图看看是否有死锁发生。例如，线程A请求锁7，但是锁7这个时候被线程B持有，这时线程A就可以检查一下线程B是否已经请求了线程A当前所持有的锁。如果线程B确实有这样的请求，那么就是发生了死锁（线程A拥有锁1，请求锁7；线程B拥有锁7，请求锁1）。

当然，死锁一般要比两个线程互相持有对方的锁这种情况要复杂的多。线程A等待线程B，线程B等待线程C，线程C等待线程D，线程D又在等待线程A。线程A为了检测死锁，它需要递进地检测所有被B请求的锁。从线程B所请求的锁开始，线程A找到了线程C，然后又找到了线程D，发现线程D请求的锁被线程A自己持有着。这是它就知道发生了死锁。

下面是一幅关于四个线程（A,B,C和D）之间锁占有和请求的关系图。像这样的数据结构就可以被用来检测死锁。

 

那么当检测出死锁时，这些线程该做些什么呢？

一个可行的做法是释放所有锁，回退，并且等待一段随机的时间后重试。这个和简单的加锁超时类似，不一样的是只有死锁已经发生了才回退，而不会是因为加锁的请求超时了。虽然有回退和等待，但是如果有大量的线程竞争同一批锁，它们还是会重复地死锁（编者注：原因同超时类似，不能从根本上减轻竞争）。

一个更好的方案是给这些线程设置优先级，让一个（或几个）线程回退，剩下的线程就像没发生死锁一样继续保持着它们需要的锁。如果赋予这些线程的优先级是固定不变的，同一批线程总是会拥有更高的优先级。为避免这个问题，可以在死锁发生的时候设置随机的优先级。

 

 

饥饿和公平

 

 

如果一个线程因为CPU时间全部被其他线程抢走而得不到CPU运行时间，这种状态被称之为“饥饿”。而该线程被“饥饿致死”正是因为它得不到CPU运行时间的机会。解决饥饿的方案被称之为“公平性” – 即所有线程均能公平地获得运行机会。

 下面是本文讨论的主题：

1. Java中导致饥饿的原因：

  • 高优先级线程吞噬所有的低优先级线程的CPU时间。
  • 线程被永久堵塞在一个等待进入同步块的状态。
  • 线程在等待一个本身也处于永久等待完成的对象(比如调用这个对象的wait方法)。

2. 在Java中实现公平性方案，需要:

  • 使用锁，而不是同步块。
  • 公平锁。
  • 注意性能方面。

Java中导致饥饿的原因

在Java中，下面三个常见的原因会导致线程饥饿：

  1. 高优先级线程吞噬所有的低优先级线程的CPU时间。
  2. 线程被永久堵塞在一个等待进入同步块的状态，因为其他线程总是能在它之前持续地对该同步块进行访问。
  3. 线程在等待一个本身(在其上调用wait())也处于永久等待完成的对象，因为其他线程总是被持续地获得唤醒。

高优先级线程吞噬所有的低优先级线程的CPU时间

你能为每个线程设置独自的线程优先级，优先级越高的线程获得的CPU时间越多，线程优先级值设置在1到10之间，而这些优先级值所表示行为的准确解释则依赖于你的应用运行平台。对大多数应用来说，你最好是不要改变其优先级值。

线程被永久堵塞在一个等待进入同步块的状态

Java的同步代码区也是一个导致饥饿的因素。Java的同步代码区对哪个线程允许进入的次序没有任何保障。这就意味着理论上存在一个试图进入该同步区的线程处于被永久堵塞的风险，因为其他线程总是能持续地先于它获得访问，这即是“饥饿”问题，而一个线程被“饥饿致死”正是因为它得不到CPU运行时间的机会。

线程在等待一个本身(在其上调用wait())也处于永久等待完成的对象

如果多个线程处在wait()方法执行上，而对其调用notify()不会保证哪一个线程会获得唤醒，任何线程都有可能处于继续等待的状态。因此存在这样一个风险：一个等待线程从来得不到唤醒，因为其他等待线程总是能被获得唤醒。

在Java中实现公平性

虽Java不可能实现100%的公平性，我们依然可以通过同步结构在线程间实现公平性的提高。

首先来学习一段简单的同步态代码：

[java] view plain copy
 
  1. public class Synchronizer{  
  2.   
  3.   public synchronized void doSynchronized(){  
  4.     //do a lot of work which takes a long time  
  5.   }  
  6.   
  7. }  

如果有一个以上的线程调用doSynchronized()方法，在第一个获得访问的线程未完成前，其他线程将一直处于阻塞状态，而且在这种多线程被阻塞的场景下，接下来将是哪个线程获得访问是没有保障的。

使用锁方式替代同步块

为了提高等待线程的公平性，我们使用锁方式来替代同步块。

[java] view plain copy
 
  1. public class Synchronizer{  
  2.   Lock lock = new Lock();  
  3.   
  4.   public void doSynchronized() throws InterruptedException{  
  5.     this.lock.lock();  //当前线程锁住lock对象  
  6.       //critical section, do a lot of work which takes a long time  
  7.     this.lock.unlock();  //当前线程释放lock对象上的锁  
  8.   }  
  9.   
  10. }  

注意到doSynchronized()不再声明为synchronized，而是用lock.lock()和lock.unlock()来替代。

下面是用Lock类做的一个实现：

[java] view plain copy
 
  1. public class Lock{  
  2.   private boolean isLocked      = false;  //是否加过锁的信号  
  3.   private Thread  lockingThread = null;   //进行加锁的线程  
  4.   
  5.   public synchronized void lock() throws InterruptedException{  
  6.     while(isLocked){  //如果lock对象已被其他线程加锁了（这个线程已经退出了本lock()方法）  
  7.       wait();  //当前线程阻塞，它释放锁对象上的锁，其他线程可以再进入本lock()  
  8.     }  
  9.     isLocked      = true;  //如果没加锁，则当前线程对锁对象加锁  
  10.     lockingThread = Thread.currentThread();  
  11.   }  
  12.   
  13.   public synchronized void unlock(){  
  14.     if(this.lockingThread != Thread.currentThread()){  //如果调用lock()加锁的不是当前线程  
  15.       throw new IllegalMonitorStateException(  
  16.         "Calling thread has not locked this lock");  
  17.     }  
  18.     isLocked      = false;  //释放锁，标记为未加锁  
  19.     lockingThread = null;  
  20.     notify();  //通知阻塞在锁对象上的线程队列，唤醒其中某一个线程  
  21.   }  
  22. }  

注意到上面对Lock的实现，如果存在多线程并发访问lock()，这些线程将阻塞在对lock()方法的访问上。另外，如果锁已经锁上（校对注：这里指的是isLocked等于true时），这些线程将阻塞在while(isLocked)循环的wait()调用里面。要记住的是，当线程正在等待进入lock() 时，可以调用wait()释放其锁实例对应的同步锁，使得其他多个线程可以进入lock()方法，并调用wait()方法。

这回看下doSynchronized()，你会注意到在lock()和unlock()之间的注释：在这两个调用之间的代码将运行很长一段时间。进一步设想，这段代码将长时间运行，和进入lock()并调用wait()来比较的话。这意味着大部分时间用在等待进入锁和进入临界区的过程是用在wait()的等待中，而不是被阻塞在试图进入lock()方法中。

在早些时候提到过，同步块不会对等待进入的多个线程谁能获得访问做任何保障，同样当调用notify()时，wait()也不会做保障一定能唤醒线程（至于为什么，请看线程通信）。因此这个版本的Lock类和doSynchronized()那个版本就保障公平性而言，没有任何区别。

但我们能改变这种情况。当前的Lock类版本调用自己的wait()方法，如果每个线程在不同的对象上调用wait()，那么只有一个线程会在该对象上调用wait()，Lock类可以决定哪个对象能对其调用notify()，因此能做到有效的选择唤醒哪个线程。

公平锁

下面来讲述将上面Lock类转变为公平锁FairLock。你会注意到新的实现和之前的Lock类中的同步和wait()/notify()稍有不同。

准确地说如何从之前的Lock类做到公平锁的设计是一个渐进设计的过程，每一步都是在解决上一步的问题而前进的：Nested Monitor Lockout（嵌套管程锁死）, Slipped Conditions（滑漏条件）和Missed Signals（丢失信号）。这些本身的讨论虽已超出本文的范围，但其中每一步的内容都将会专题进行讨论。重要的是，每一个调用lock()的线程都会进入一个队列，当解锁后，只有队列里的第一个线程被允许锁住FairLock实例，所有其它的线程都将处于等待状态，直到他们处于队列头部。

[java] view plain copy
 
  1. public class FairLock {  
  2.     private boolean           isLocked       = false;  //是否加锁的信号  
  3.     private Thread            lockingThread  = null;   //加锁的线程  
  4.     private List<QueueObject> waitingThreads =  
  5.             new ArrayList<QueueObject>();   //信号量队列  
  6.   
  7.   public void lock() throws InterruptedException{  //多个线程可同时进入  
  8.     QueueObject queueObject           = new QueueObject();  //局部对象，线程安全  
  9.     boolean     isLockedForThisThread = true;  //是否为当前线程加锁  
  10.     synchronized(this){  //将当前线程（用信号量）推入队列  
  11.         waitingThreads.add(queueObject);  
  12.     }  
  13.   
  14.     while(isLockedForThisThread){  
  15.         synchronized(this){  //加锁操作需要同步  
  16.           //锁状态依然被检查和设置，以避免出现滑漏条件  
  17.           isLockedForThisThread = isLocked || waitingThreads.get(0) != queueObject;  
  18.           if(!isLockedForThisThread){ //如果对象未加锁且队列头部是当前线程  
  19.               isLocked = true; //加锁  
  20.               waitingThreads.remove(queueObject); //从队列中移除当前线程  
  21.               lockingThread = Thread.currentThread(); return;   
  22.           }   
  23.         }   
  24.         try{ //放在同步块之外，避免monitor嵌套锁死   
  25.             queueObject.doWait(); //监视器对象（持有信号量isNotified）等待  
  26.         }catch(InterruptedException e){   
  27.            synchronized(this) { waitingThreads.remove(queueObject); }   
  28.             throw e;   
  29.         }   
  30.     }   
  31.   }   
  32.   
  33.   public synchronized void unlock(){   
  34.       if(this.lockingThread != Thread.currentThread()){ //加锁的不是当前线程   
  35.           throw new IllegalMonitorStateException( "Calling thread has not locked this lock");   
  36.       }   
  37.       isLocked = false; //解锁   
  38.       lockingThread = null;   
  39.       if(waitingThreads.size() > 0){ //唤醒第一个线程   
  40.           waitingThreads.get(0).doNotify();   
  41.       }   
  42.   }  
  43. }  
[java] view plain copy
 
  1. public class QueueObject {  
  2.   
  3.   private boolean isNotified = false;  
  4.   
  5.   public synchronized void doWait() throws InterruptedException {  
  6.     while(!isNotified){  
  7.         this.wait();  
  8.     }  
  9.     this.isNotified = false;  
  10.   }  
  11.   
  12.   public synchronized void doNotify() {  
  13.     this.isNotified = true;  
  14.     this.notify();  
  15.   }  
  16.   
  17.   public boolean equals(Object o) {  
  18.     return this == o;  
  19.   }  
  20. }  

首先注意到lock()方法不再声明为synchronized，取而代之的是对必需同步的代码，在synchronized中进行嵌套。

FairLock新创建了一个QueueObject的实例，并对每个调用lock()的线程都将其QueueObject实例推入队列。调用unlock()的线程将从队列头部获取QueueObject，并对其调用doNotify()，以唤醒在该对象上等待的线程。通过这种方式，在同一时间仅有一个等待线程获得唤醒，而不是所有的等待线程。这也是实现FairLock公平性的核心所在。

 

请注意，在同一个同步块中，锁状态依然被检查和设置，以避免出现滑漏条件。

还需注意到，QueueObject实际是一个semaphore。doWait()和doNotify()方法在QueueObject中保存着信号。这样做以避免一个线程在调用queueObject.doWait()之前被另一个调用unlock()并随之调用queueObject.doNotify()的线程重入，从而导致信号丢失。queueObject.doWait()调用放置在synchronized(this)块之外，以避免被monitor嵌套锁死，所以另外的线程可以进入unlock()来解锁，只要当没有线程在lock方法的synchronized(this)块中执行即可。

最后，注意到queueObject.doWait()在try – catch块中是怎样调用的。在InterruptedException抛出的情况下，线程得以离开lock()，并需让它从队列中移除。

性能考虑

如果比较Lock和FairLock类，你会注意到在FairLock类中lock()和unlock()还有更多需要深入的地方。这些额外的代码会导致FairLock的同步机制实现比Lock要稍微慢些。究竟存在多少影响，还依赖于应用在FairLock临界区执行的时长。执行时长越大，FairLock带来的负担影响就越小，当然这也和代码执行的频繁度相关。

 

嵌套管程锁死


嵌套管程锁死类似于死锁， 下面是一个嵌套管程锁死的场景：

[html] view plain copy
 
  1. 线程1 获得A对象的锁。  
  2. 线程1 获得对象B的锁（同时持有对象A的锁）。  
  3. 线程1 决定等待另一个线程的信号再继续。  
  4. 线程1 调用B.wait()，从而释放了B对象上的锁，但仍然持有对象A的锁。  
  5.   
  6. 线程2 需要同时持有对象A和对象B的锁，才能向线程1发信号。  
  7. 线程2 无法获得对象A上的锁，因为对象A上的锁当前正被线程1持有。  
  8. 线程2 一直被阻塞，等待线程1释放对象A上的锁。  
  9.   
  10. 线程1 一直阻塞，等待线程2的信号，因此，不会释放对象A上的锁，  
  11.     而线程2需要对象A上的锁才能给线程1发信号……  

你可以能会说，这是个空想的场景，好吧，让我们来看看下面这个比较挫的Lock实现：

[java] view plain copy
 
  1. //lock implementation with nested monitor lockout problem  
  2.   
  3. public class Lock{  
  4.   protected MonitorObject monitorObject = new MonitorObject();  
  5.   protected boolean isLocked = false;  
  6.   
  7.   public void lock() throws InterruptedException{  
  8.     synchronized(this){  
  9.       while(isLocked){  
  10.         synchronized(this.monitorObject){  
  11.             this.monitorObject.wait();  
  12.         }  
  13.       }  
  14.       isLocked = true;  
  15.     }  
  16.   }  
  17.   
  18.   public void unlock(){  
  19.     synchronized(this){  
  20.       this.isLocked = false;  
  21.       synchronized(this.monitorObject){  
  22.         this.monitorObject.notify();  
  23.       }  
  24.     }  
  25.   }  
  26. }  

可以看到，lock()方法首先在”this”上同步，然后在monitorObject上同步。如果isLocked等于false，因为线程不会继续调用monitorObject.wait()，那么一切都没有问题 。但是如果isLocked等于true，调用lock()方法的线程会在monitorObject.wait()上阻塞。

这里的问题在于，调用monitorObject.wait()方法只释放了monitorObject上的管程对象，而与”this“关联的管程对象并没有释放。换句话说，这个刚被阻塞的线程仍然持有”this”上的锁。

（校对注：如果一个线程持有这种Lock的时候另一个线程执行了lock操作）当一个已经持有这种Lock的线程想调用unlock()，就会在unlock()方法进入synchronized(this)块时阻塞。这会一直阻塞到在lock()方法中等待的线程离开synchronized(this)块。但是，在unlock中isLocked变为false，monitorObject.notify()被执行之后，lock()中等待的线程才会离开synchronized(this)块。

简而言之，在lock方法中等待的线程需要其它线程成功调用unlock方法来退出lock方法，但是，在lock()方法离开外层同步块之前，没有线程能成功执行unlock()。

结果就是，任何调用lock方法或unlock方法的线程都会一直阻塞。这就是嵌套管程锁死。

一个更现实的例子

你可能会说，这么挫的实现方式我怎么可能会做呢？你或许不会在里层的管程对象上调用wait或notify方法，但完全有可能会在外层的this上调。
有很多类似上面例子的情况。例如，如果你准备实现一个公平锁。你可能希望每个线程在它们各自的QueueObject上调用wait()，这样就可以每次唤醒一个线程。

下面是一个比较挫的公平锁实现方式：

[java] view plain copy
 
  1. //Fair Lock implementation with nested monitor lockout problem  
  2.   
  3. public class FairLock {  
  4.   private boolean           isLocked       = false;  
  5.   private Thread            lockingThread  = null;  
  6.   private List<QueueObject> waitingThreads =  
  7.             new ArrayList<QueueObject>();  
  8.   
  9.   public void lock() throws InterruptedException{  
  10.     QueueObject queueObject = new QueueObject();  
  11.   
  12.     synchronized(this){  
  13.       waitingThreads.add(queueObject);  
  14.   
  15.       while(isLocked || waitingThreads.get(0) != queueObject){  
  16.   
  17.         synchronized(queueObject){  
  18.           try{  
  19.             queueObject.wait();  
  20.           }catch(InterruptedException e){  
  21.             waitingThreads.remove(queueObject);  
  22.             throw e;  
  23.           }  
  24.         }  
  25.       }  
  26.       waitingThreads.remove(queueObject);  
  27.       isLocked = true;  
  28.       lockingThread = Thread.currentThread();  
  29.     }  
  30.   }  
  31.   
  32.   public synchronized void unlock(){  
  33.     if(this.lockingThread != Thread.currentThread()){  
  34.       throw new IllegalMonitorStateException(  
  35.         "Calling thread has not locked this lock");  
  36.     }  
  37.     isLocked      = false;  
  38.     lockingThread = null;  
  39.     if(waitingThreads.size() > 0){  
  40.       QueueObject queueObject = waitingThread.get(0);  
  41.       synchronized(queueObject){  
  42.         queueObject.notify();  
  43.       }  
  44.     }  
  45.   }  
  46. }  

 

[java] view plain copy
 
  1. public class QueueObject {}  

 

乍看之下，嗯，很好，但是请注意lock方法是怎么调用queueObject.wait()的，在方法内部有两个synchronized块，一个锁定this，一个嵌在上一个synchronized块内部，它锁定的是局部变量queueObject。
当一个线程调用queueObject.wait()方法的时候，它仅仅释放的是在queueObject对象实例的锁，并没有释放”this”上面的锁。

现在我们还有一个地方需要特别注意， unlock方法被声明成了synchronized，这就相当于一个synchronized（this）块。这就意味着，如果一个线程在lock()中等待，该线程将持有与this关联的管程对象。所有调用unlock()的线程将会一直保持阻塞，等待着前面那个已经获得this锁的线程释放this锁，但这永远也发生不了，因为只有某个线程成功地给lock()中等待的线程发送了信号，this上的锁才会释放，但只有执行unlock()方法才会发送这个信号。

因此，上面的公平锁的实现会导致嵌套管程锁死。更好的公平锁实现方式可以参考Starvation and Fairness。

总结：

嵌套管程锁死：在加锁函数lock()中，线程在嵌套的同步块内调用管程对象上的wait()阻塞自己，这只会释放管程对象的上锁，而不会释放锁对象上的锁。导致其他线程不能进入unlock()来唤醒前面阻塞的线程，而是自己也会被阻塞。一方持有锁并阻塞，等待另一方的唤醒信号，而另一方需要这个锁才能发信号，因此也只能阻塞，从而锁死，这就是嵌套管程锁死。解决方法是把调用管程对象的wait()操作的嵌套同步块移到外层，这样其他线程可进入unlock()来唤醒阻塞的线程。

嵌套管程锁死 VS 死锁

嵌套管程锁死与死锁很像：都是线程最后被一直阻塞着互相等待。

但是两者又不完全相同。在死锁中我们已经对死锁有了个大概的解释，死锁通常是因为两个线程获取锁的顺序不一致造成的，线程1锁住A，等待获取B，线程2已经获取了B，再等待获取A。如死锁避免中所说的，死锁可以通过总是以相同的顺序获取锁来避免。
但是发生嵌套管程锁死时锁获取的顺序是一致的。线程1获得A和B，然后释放B，等待线程2的信号。线程2需要同时获得A和B，才能向线程1发送信号。所以，一个线程在等待唤醒，另一个线程在等待想要的锁被释放。

不同点归纳如下：

[plain] view plain copy
 
  1. 死锁中，二个线程都在等待对方释放锁。  
  2.   
  3. 嵌套管程锁死中，线程1持有锁A，同时等待从线程2发来的信号，线程2需要锁A来发信号给线程1。  

 

滑漏条件

 

所谓滑漏条件Slipped conditions，就是说， 从一个线程检查某一特定条件到该线程操作此条件期间，这个条件已经被其它线程改变，导致第一个线程在该条件上执行了错误的操作。这里有一个简单的例子：

[java] view plain copy
 
  1. public class Lock {  
  2.   
  3.     private boolean isLocked = true;  
  4.   
  5.     public void lock(){  
  6.       synchronized(this){  
  7.         while(isLocked){  
  8.           try{  
  9.             this.wait();  
  10.           } catch(InterruptedException e){  
  11.             //do nothing, keep waiting  
  12.           }  
  13.         }  
  14.       }  
  15.   
  16.       synchronized(this){  
  17.         isLocked = true;  
  18.       }  
  19.     }  
  20.   
  21.     public synchronized void unlock(){  
  22.       isLocked = false;  
  23.       this.notify();  
  24.     }  
  25.   
  26. }  

我们可以看到，lock()方法包含了两个同步块。第一个同步块执行wait操作直到isLocked变为false才退出，第二个同步块将isLocked置为true，以此来锁住这个Lock实例避免其它线程通过lock()方法。

我们可以设想一下，假如在某个时刻isLocked为false， 这个时候，有两个线程同时访问lock方法。如果第一个线程先进入第一个同步块，这个时候它会发现isLocked为false，在退出第一个同步块而进入第二个同步块之前，若此时允许第二个线程执行，它也进入第一个同步块，同样发现isLocked是false。现在两个线程都检查了这个条件为false，然后它们都会继续进入第二个同步块中并设置isLocked为true。（译注：导致两个线程都会进入lock()后面的临界区，不能保证只有一个线程进入临界区而其他线程等待。）

这个场景就是slipped conditions的例子，两个线程检查同一个条件， 然后退出同步块，因此在这两个线程改变条件之前，就允许其它线程来检查这个条件。换句话说，条件被某个线程检查到该条件被此线程改变期间，这个条件已经被其它线程改变过了。

为避免slipped conditions，条件的检查与设置必须是原子的，也就是说，在第一个线程检查和设置条件期间，不会有其它线程检查这个条件。

解决上面问题的方法很简单，只是简单的把isLocked = true这行代码移到第一个同步块中，放在while循环后面即可：

[java] view plain copy
 
  1. public class Lock {  
  2.   
  3.     private boolean isLocked = true;  
  4.   
  5.     public void lock(){  
  6.       synchronized(this){  
  7.         while(isLocked){  
  8.           try{  
  9.             this.wait();  
  10.           } catch(InterruptedException e){  
  11.             //do nothing, keep waiting  
  12.           }  
  13.         }  
  14.         isLocked = true;  
  15.       }  
  16.     }  
  17.   
  18.     public synchronized void unlock(){  
  19.       isLocked = false;  
  20.       this.notify();  
  21.     }  
  22.   
  23. }  

现在检查和设置isLocked条件是在同一个同步块中原子地执行了。

一个更现实的例子

也许你会说，我才不可能写这么挫的代码，还觉得slipped conditions是个相当理论的问题。但是第一个简单的例子只是用来更好的展示slipped conditions。

饥饿和公平中实现的公平锁也许是个更现实的例子。再看下嵌套管程锁死中那个幼稚的实现，如果我们试图解决其中的嵌套管程锁死问题，很容易产生slipped conditions问题。 首先让我们看下嵌套管程锁死中的例子：

[java] view plain copy
 
  1. //Fair Lock implementation with nested monitor lockout problem  
  2.   
  3. public class FairLock {  
  4.   private boolean           isLocked       = false;  
  5.   private Thread            lockingThread  = null;  
  6.   private List<QueueObject> waitingThreads =  
  7.             new ArrayList<QueueObject>();  
  8.   
  9.   public void lock() throws InterruptedException{  
  10.     QueueObject queueObject = new QueueObject();  
  11.   
  12.     synchronized(this){  
  13.       waitingThreads.add(queueObject);  
  14.   
  15.       while(isLocked || waitingThreads.get(0) != queueObject){  
  16.         synchronized(queueObject){  
  17.           try{  
  18.             queueObject.wait();  
  19.           }catch(InterruptedException e){  
  20.             waitingThreads.remove(queueObject);  
  21.             throw e;  
  22.           }  
  23.         }  
  24.       }  
  25.       waitingThreads.remove(queueObject);  
  26.       isLocked = true;  
  27.       lockingThread = Thread.currentThread();  
  28.     }  
  29.   }  
  30.   
  31.   public synchronized void unlock(){  
  32.     if(this.lockingThread != Thread.currentThread()){  
  33.       throw new IllegalMonitorStateException(  
  34.         "Calling thread has not locked this lock");  
  35.     }  
  36.     isLocked      = false;  
  37.     lockingThread = null;  
  38.     if(waitingThreads.size() > 0){  
  39.       QueueObject queueObject = waitingThread.get(0);  
  40.       synchronized(queueObject){  
  41.         queueObject.notify();  
  42.       }  
  43.     }  
  44.   }  
  45. }  

我们可以看到synchronized(queueObject)及其中的queueObject.wait()调用是嵌在synchronized(this)块里面的，这会导致嵌套管程锁死问题。为避免这个问题，我们必须将synchronized(queueObject)块移出synchronized(this)块。移出来之后的代码可能是这样的：

[java] view plain copy
 
  1. //Fair Lock implementation with slipped conditions problem  
  2.   
  3. public class FairLock {  
  4.   private boolean           isLocked       = false;  
  5.   private Thread            lockingThread  = null;  
  6.   private List<QueueObject> waitingThreads =  
  7.             new ArrayList<QueueObject>();  
  8.   
  9.   public void lock() throws InterruptedException{  
  10.     QueueObject queueObject = new QueueObject();  
  11.   
  12.     synchronized(this){  
  13.       waitingThreads.add(queueObject);  
  14.     }  
  15.   
  16.     boolean mustWait = true;  
  17.     while(mustWait){  
  18.   
  19.       synchronized(this){  
  20.         mustWait = isLocked || waitingThreads.get(0) != queueObject;  
  21.       }  
  22.   
  23.       synchronized(queueObject){  
  24.         if(mustWait){  
  25.           try{  
  26.             queueObject.wait();  
  27.           }catch(InterruptedException e){  
  28.             waitingThreads.remove(queueObject);  
  29.             throw e;  
  30.           }  
  31.         }  
  32.       }  
  33.     }  
  34.   
  35.     synchronized(this){  
  36.       waitingThreads.remove(queueObject);  
  37.       isLocked = true;  
  38.       lockingThread = Thread.currentThread();  
  39.     }  
  40.   }  
  41. }  

注意：因为我只改动了lock()方法，这里只展现了lock方法。

现在lock()方法包含了3个同步块。

第一个，synchronized(this)块通过mustWait = isLocked || waitingThreads.get(0) != queueObject检查内部变量的值。

第二个，synchronized(queueObject)块检查线程是否需要等待。也有可能其它线程在这个时候已经解锁了，但我们暂时不考虑这个问题。我们就假设这个锁处在解锁状态，所以线程会立马退出synchronized(queueObject)块。

第三个，synchronized(this)块只会在mustWait为false的时候执行。它将isLocked重新设回true，然后离开lock()方法。

设想一下，在锁处于解锁状态时，如果有两个线程同时调用lock()方法会发生什么。首先，线程1会检查到isLocked为false，然后线程2同样检查到isLocked为false。接着，它们都不会等待，都会去设置isLocked为true。这就是slipped conditions的一个最好的例子。

消除滑漏条件问题

要消除上面例子中的slipped conditions问题，最后一个synchronized(this)块中的代码必须向上移到第一个同步块中。为适应这种变动，代码需要做点小改动。下面是改动过的代码：

[java] view plain copy
 
  1. //Fair Lock implementation without nested monitor lockout problem,  
  2. //but with missed signals problem.  
  3.   
  4. public class FairLock {  
  5.   private boolean           isLocked       = false;  
  6.   private Thread            lockingThread  = null;  
  7.   private List<QueueObject> waitingThreads =  
  8.             new ArrayList<QueueObject>();  
  9.   
  10.   public void lock() throws InterruptedException{  
  11.     QueueObject queueObject = new QueueObject();  
  12.   
  13.     synchronized(this){  
  14.       waitingThreads.add(queueObject);  
  15.     }  
  16.   
  17.     boolean mustWait = true;  
  18.     while(mustWait){        
  19.       synchronized(this){  
  20.         mustWait = isLocked || waitingThreads.get(0) != queueObject;  
  21.         if(!mustWait){  
  22.           waitingThreads.remove(queueObject);  
  23.           isLocked = true;  
  24.           lockingThread = Thread.currentThread();  
  25.           return;  
  26.         }  
  27.       }       
  28.   
  29.      synchronized(queueObject){  
  30.         if(mustWait){  
  31.           try{  
  32.             queueObject.wait();  
  33.           }catch(InterruptedException e){  
  34.             waitingThreads.remove(queueObject);  
  35.             throw e;  
  36.           }  
  37.         }  
  38.       }  
  39.     }  
  40.   }  
  41.   
  42.   public synchronized void unlock(){  
  43.     if(this.lockingThread != Thread.currentThread()){  
  44.       throw new IllegalMonitorStateException(  
  45.         "Calling thread has not locked this lock");  
  46.     }  
  47.     isLocked      = false;  
  48.     lockingThread = null;  
  49.     if(waitingThreads.size() > 0){  
  50.       QueueObject queueObject = waitingThread.get(0);  
  51.       synchronized(queueObject){  
  52.         queueObject.notify();  
  53.       }  
  54.     }  
  55.   }  
  56. }  

我们可以看到对局部变量mustWait的检查与赋值是在同一个同步块中完成的。还可以看到，即使在synchronized(this)块外面检查了mustWait，在while(mustWait)子句中，mustWait变量从来没有在synchronized(this)同步块外被赋值。当一个线程检查到mustWait是false的时候，它将自动设置内部的条件（isLocked），所以其它线程再来检查这个条件的时候，它们就会发现这个条件的值现在为true了。

synchronized(this)块中的return;语句不是必须的。这只是个小小的优化。如果一个线程肯定不会等待（即mustWait为false），那么就没必要让它进入到synchronized(queueObject)同步块中和执行if(mustWait)子句了。

细心的读者可能会注意到上面的公平锁实现仍然有可能丢失信号。设想一下，当该FairLock实例处于锁定状态时，有个线程来调用lock()方法。执行完第一个synchronized(this)块后，mustWait变量的值为true。再设想一下调用lock()的线程被其他线程抢占了，拥有锁的那个线程此时调用了unlock()方法，但是看下之前的unlock()的实现你会发现，它调用了queueObject.notify()。但是，因为lock()中的线程还没有来得及调用queueObject.wait()，所以queueObject.notify()调用也就没有作用了，信号就丢失掉了。如果调用lock()的线程在另一个线程调用queueObject.notify()之后调用queueObject.wait()，这个线程会一直阻塞到其它线程调用unlock方法为止，但这永远也不会发生。

公平锁实现的信号丢失问题在饥饿和公平一文中我们已有过讨论，把QueueObject转变成一个信号量，并提供两个方法：doWait()和doNotify()。这些方法会在QueueObject内部对信号进行存储和响应。用这种方式，即使doNotify()在doWait()之前调用，信号也不会丢失。

总结：

    滑漏条件：在加锁函数lock()中，如果锁状态的检查和设置在两个独立的同步块中，这会导致一个线程在检查锁状态为false并且还没进入另一个同步块设置加锁时，其他线程也可以进入前一同步块并且检查出锁状态为false，从而多个线程都不会等待，都会进入后一同步块设置锁为true。然后多个线程都会进入lock()后面的临界区，同步失效。这就是滑漏条件。解决方法是把锁状态的检查与设置放在一个同步块中，保持原子性。

    丢失信号：一个线程在被通知线程调用wait()之前去调用notify()进行通知，导致通知信号丢失。被通知线程错过了唤醒信号，将永远等待。解决方法是把信号保存在一个类中，在这个信号类中用一个变量来保存是否被通知过。在notify前，设置自己已经被通知过。在线程准备wait时，检查这个变量，如果已经被通知过，就不调用wait()了，从而避免永久等待。然后设置自己没有被通知过，需要等待通知。

    假唤醒：线程在没有调用过notify()和notifyAll()的情况下无端地醒来，比如由于程序的bug或不正确的信号，这就是假唤醒（spurious wakeups）。假唤醒后，线程能够执行后续的操作，这可能导致应用程序出现严重问题。解决方法是把保存信号的成员变量放在一个while循环里接受检查（如上面的mustWait），而不是在if表达式里。这样的一个while循环叫做自旋锁。等待线程会一直在while循环中自旋，直到收到唤醒信号使循环条件为false。如果它没有收到信号就唤醒，循环条件仍为true，while循环会再执行一次，促使醒来的线程回到等待状态。

 

英文原文：http://tutorials.jenkov.com/java-concurrency/index.html

中文参考：http://ifeve.com/java-concurrency-thread-directory/

http://blog.csdn.net/linfanhehe/article/details/51130492

posted on 2018-01-10 10:31  ziq711  阅读(1551)  评论(0)  编辑  收藏  举报