java并发（十）死锁 & 活锁

活锁：一个线程通常会有会响应其他线程的活动。如果其他线程也会响应另一个线程的活动，那么就有可能发生活锁。同死锁一样，发生活锁的线程无法继续执行。然而线程并没有阻塞——他们在忙于响应对方无法恢复工作。这就相当于两个在走廊相遇的人：Alphonse向他自己的左边靠想让Gaston过去，而Gaston向他的右边靠想让Alphonse过去。可见他们阻塞了对方。Alphonse向他的右边靠，而Gaston向他的左边靠，他们还是阻塞了对方。



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



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

该情况如下：

Java代码  

1. //Thread 1  locks A, waits for B  
2. //Thread 2  locks B, waits for A  
3. 这里有一个TreeNode类的例子，它调用了不同实例的synchronized方法：  
4.   
5. public class TreeNode {  
6.     TreeNode parent   = null;   
7.     List children = new ArrayList();  
8.     public synchronized void addChild(TreeNode child){  
9.         if(!this.children.contains(child)) {  
10.             this.children.add(child);  
11.             child.setParentOnly(this);  
12.         }  
13.     }  
14.     public synchronized void addChildOnly(TreeNode child){  
15.         if(!this.children.contains(child){  
16.             this.children.add(child);  
17.         }  
18.     }  
19.     public synchronized void setParent(TreeNode parent){  
20.         this.parent = parent;  
21.         parent.addChildOnly(this);  
22.     }  
23.     public synchronized void setParentOnly(TreeNode parent){  
24.         this.parent = parent;  
25.     }  
26. }  

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

TreeNode parent = new TreeNode();

TreeNode child = new TreeNode();

Thread 1: parent.addChild(child); //locks parent

          --> child.setParentOnly(parent);



Thread 2: child.setParent(parent); //locks child

          --> parent.addChildOnly(child)

首先线程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个线程发生死锁的例子：

Thread 1  locks A, waits for B

Thread 2  locks B, waits for C

Thread 3  locks C, waits for D

Thread 4  locks D, waits for A

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



数据库的死锁

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



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



Transaction 1, request 1, locks record 1 for update

Transaction 2, request 1, locks record 2 for update

Transaction 1, request 2, tries to lock record 2 for update.

Transaction 2, request 2, tries to lock record 1 for update.

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



另外一个死锁的例子

Java代码  

1. package com.chinaso.search.executor;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5.   
6. public class TestLock {  
7.     private static ExecutorService executor = Executors.newFixedThreadPool(10);  
8.     private String name;  
9.   
10.     /** 
11.      * 同步方法1 
12.      * @return 
13.      */  
14.     public synchronized String getName() {  
15.         return name;  
16.     }  
17.   
18.     /** 
19.      * 同步方法2 
20.      * @param t 
21.      */  
22.     public synchronized void print(TestLock t) {  
23.         while (true) {  
24.             try {  
25.                 Thread.sleep(1000);  
26.                 System.out.println(name + " end sleep");  
27.             } catch (InterruptedException e) {  
28.                 e.printStackTrace();  
29.             }  
30.             System.out.println(t.getName() + " synchroinzed");  
31.         }  
32.     }  
33.   
34.     public void setName(String name) {  
35.         this.name = name;  
36.     }  
37.   
38.     public TestLock(String name) {  
39.         this.name = name;  
40.     }  
41.   
42.     public static void main(String[] args) throws Exception {  
43.   
44.         final TestLock t1 = new TestLock("t1");  
45.         final TestLock t2 = new TestLock("t2");  
46.   
47.         executor.execute(new Runnable() {  
48.             @Override  
49.             public void run() {  
50.                 t1.print(t2);  
51.             }  
52.         });  
53.   
54.         executor.execute(new Runnable() {  
55.             @Override  
56.             public void run() {  
57.                 t2.print(t1);  
58.             }  
59.         });  
60.   
61.     }  
62. }