死锁看的不太懂，谁能给个死锁程序吗，尽量简单，能够说明问题就好。好人一生平安{:3_64:}

fantacyleo 发表于 2014-8-2 01:19
我把Oracle官方的死锁程序给你吧，既简单，又有趣

thankyou thankyou

ily521125 发表于 2014-8-1 17:07

十分感谢

学习了~

我把Oracle官方的死锁程序给你吧，既简单，又有趣

1. /**
   
2. * 死锁示例：
   
3. *         张三李四相互鞠躬问候。
   
4. *                 张三看到李四向自己鞠躬后，就鞠躬回礼（调用李四的bowBack方法）。
   
5. *                 李四看到张三向自己鞠躬后，也鞠躬回礼（调用张三的bowBack方法）。
   
6. *                 张三拿着张三对象的锁，想调李四的bowBack方法
   
7. *                 李四拿着李四对象的锁，想调张三的bowBack方法
   
8. *                 互相拿着对方需要的锁，造成死锁
   
9. *
   
10. * @author lihao
    
11. *
    
12. */
    
13. public class DeadlockDemo {
    
14.    
    
15.     public static void main(String[] args) {
    
16.         final Friend zhangsan = new Friend("张三");
    
17.         final Friend lisi = new Friend("李四");
    
18. 
    
19.         Thread t1 = new Thread(new Runnable() {
    
20.             public void run() { zhangsan.bow(lisi); }
    
21.         }); // 张三向李四鞠躬
    
22. 
    
23.         Thread t2 = new Thread(new Runnable() {
    
24.             public void run() { lisi.bow(zhangsan); }
    
25.         }); // 李四向张三鞠躬
    
26.         
    
27.         t1.start();
    
28.         t2.start();
    
29.     }
    
30. }
    
31. 
    
32. class Friend {
    
33.         private String name;
    
34.         public Friend(String name) {
    
35.             this.name = name;
    
36.         }
    
37.         public String getName() {
    
38.             return this.name;
    
39.         }
    
40.         public synchronized void bow(Friend bower) {
    
41.                 System.out.println(this.name + "说：" + bower.getName() + "向我鞠躬问候了");
    
42.             bower.bowBack(this);
    
43.         }
    
44.         public synchronized void bowBack(Friend bower) {
    
45.                 System.out.println(this.name + "说：" + bower.getName() + "向我鞠躬回礼了");
    
46.         }
    
47.     }
    

复制代码

同步那地方

两个进程资源占用是互斥就行了

示例的程序里锁只有两把噢，别搞混了。如果线程进了第一个synchronized而进不去第二个，是因为第二个已经被另一个线程拿了。你跟着线程走一下就好理解了。

你记好就成了，同步中最好别用嵌套，就是同步中有同步，就能很大程度避免死锁。

A里锁个B  B里锁个A

1. /*
   
2. 死锁：
   
3.         同步中嵌套同步
   
4.         如：在多线程中，线程一中locka锁嵌套lockb锁，线程二中lockb锁嵌套locka锁，会发生死锁
   
5.         注：locka lockb为锁对象
   
6. */
   
7. class Test implements Runnable
   
8. {
   
9.         private boolean flag;
   
10.         Test(boolean flag)
    
11.         {
    
12.                 this.flag=flag;
    
13.         }
    
14.         public void run()
    
15.         {
    
16.                 if(flag)
    
17.                 {
    
18.                         synchronized(MyLock.locka) //锁对象为locka
    
19.                         {
    
20.                                 System.out.println(Thread.currentThread().getName()+"...if locka");
    
21.                                 synchronized(MyLock.lockb) //锁对象为lockb
    
22.                                 {
    
23.                                         System.out.println(Thread.currentThread().getName()+"...if lockb");
    
24.                                 }
    
25.                         }
    
26.                 }
    
27.                 else
    
28.                 {
    
29.                         synchronized(MyLock.lockb) //锁对象为lockb
    
30.                         {
    
31.                                 System.out.println(Thread.currentThread().getName()+"...if lockb");
    
32.                                 synchronized(MyLock.locka) //锁对象为locka
    
33.                                 {
    
34.                                         System.out.println(Thread.currentThread().getName()+"...if locka");
    
35.                                 }
    
36.                         }
    
37.                 }
    
38.         }
    
39. }
    
40. class MyLock
    
41. {
    
42.         //创建两个Object对象
    
43.         static Object locka=new Object();
    
44.         static Object lockb=new Object();
    
45. }
    
46. class DeadLockTest
    
47. {
    
48.         public static void main(String[] args)
    
49.         {
    
50.                 Thread t1=new Thread(new Test(true)); //创建线程一，并添加一个对象
    
51.                 Thread t2=new Thread(new Test(false)); //创建线程二，并添加一个对象
    
52.                 t1.start(); //启动线程一
    
53.                 t2.start(); //启动线程二
    
54.         }
    
55. }

复制代码

多线程中，同步嵌套同步会发生死锁