java多线程中死锁情况的一个示例

 下面是死锁情况的一个示例代码

[java]  view plain copy

1. package com.qust.demo.money;  
2.   
3. class A {  
4.   
5.     public synchronized void foo(B b) {  
6.         System.out.println(Thread.currentThread().getName() + " 进入A的foo");  
7.         try {  
8.             Thread.sleep(200);  
9.         } catch (InterruptedException ex) {  
10.             ex.printStackTrace();  
11.         }  
12.         System.out.println(Thread.currentThread().getName() + " 试图调用B的last");  
13.         b.last();  
14.     }  
15.   
16.     public synchronized void last() {  
17.         System.out.println("A的last()");  
18.     }  
19. }  
20.   
21. class B {  
22.   
23.     public synchronized void bar(A a) {  
24.         System.out.println(Thread.currentThread().getName() + " 进入B的bar");  
25.         try {  
26.             Thread.sleep(200);  
27.         } catch (InterruptedException ex) {  
28.             ex.printStackTrace();  
29.         }  
30.         System.out.println(Thread.currentThread().getName() + " 试图调用A的last");  
31.         a.last();  
32.     }  
33.   
34.     public synchronized void last() {  
35.         System.out.println("B的last()");  
36.     }  
37. }  
38.   
39. public class DeadLock implements Runnable {  
40.   
41.     A a = new A();  
42.     B b = new B();  
43.   
44.     public void init() {  
45.         Thread.currentThread().setName("主线程");  
46.         System.out.println("进入主线程");  
47.         a.foo(b);  
48.     }  
49.   
50.     public void run() {  
51.         Thread.currentThread().setName("副线程");  
52.         System.out.println("进入副线程");  
53.         b.bar(a);  
54.     }  
55.   
56.     public static void main(String[] args) {  
57.         DeadLock dl = new DeadLock();  
58.         new Thread(dl).start();  
59.         dl.init();  
60.     }  
61. }  

[html]  view plain copy

1. 进入主线程  
2. 进入副线程  
3. 主线程 进入A的foo  
4. 副线程 进入B的bar  
5. 副线程 试图调用A的last  
6. 主线程 试图调用B的last  

    在上面的代码里面，为什么会出现死锁这种情况呢？我们来简单分析一下。

    首先虽然副线程的start()是在主线程的init()之前，但是因为多线程开启也需要一段时间，所以我们可以看到，是主线程的init()方法执行在前，然后在init()里面调用了a.foo()。A类和B类中的方法都是同步方法，因此，A的对象和B的对象都是同步锁。在进入A的foo()之前，线程会对A加锁，然后线程睡眠200ms，这时候副线程调用B的bar()，同样的会对B加锁，然后睡眠200ms。这时候，主线程唤醒，试图调用B的bar方法，因为是同步方法，所以需要对B加锁，但是这时候B已经被副线程锁住了，所以主线程就一直处于阻塞状态。当副线程唤醒的时候，试图调用A的同步方法，同样需要对A加锁，但是这时候主线程持有A的锁，并处于阻塞状态，所以副线程也不能向下执行，大家都在等着对方释放锁，因此出现了我们上面说的死锁的情况。

    如果我们把A和B的last()的synchronized去掉，那么程序在调用last()之前就不需要对对象进行加锁，也就不会出现死锁的情况。

    因为在工作中还没有遇到这种情况，所以只能拿这个实例程序讲解了。