我模仿毕老师的视频，写了个死锁的程序，不知道那里错了，运行了几次，锁不上，也没找到原因，求解。

class  DeadLock implements Runnable{
        private boolean flag;
        DeadLock(boolean flag){
                this.flag = flag;
        }
        public void run(){
                while (true){
                        if (this.flag){
                                synchronized(MyLock.locka){
                                        try{Thread.sleep(10);}catch(Exception e){}
                                        System.out.println("if---locka");
                                }
                                synchronized(MyLock.lockb){
                                        try{Thread.sleep(10);}catch(Exception e){}
                                        System.out.println("if---lockb");
                                }                        
                        }
                        else{
                                synchronized(MyLock.lockb){
                                        try{Thread.sleep(10);}catch(Exception e){}
                                        System.out.println("else---lockb");
                                }
                                synchronized(MyLock.locka){
                                        try{Thread.sleep(10);}catch(Exception e){}
                                        System.out.println("else---locka");
                                }                        
                        }
                }
        }
}

class MyLock{
        private String name;
        static MyLock locka = new MyLock("locka");
        static MyLock lockb = new MyLock("lockb");
        MyLock(String name){
                this.name =name;               
        }
}




class DeadLockDemo
{
        public static void main(String[] args)
        {
                DeadLock d1 = new DeadLock(true);
                DeadLock d2 = new DeadLock(false);
                Thread t1 = new Thread(d1);
                Thread t2 = new Thread(d2);
                t1.start();
                t2.start();
        }
}

死锁是同步块嵌套,你这个根本不满足,简单给你改一下,你根据我的更改实现就行了.看下我刚写的,你就明白了.

1. public void run(){
   
2.                 while(true){
   
3.                         try{
   
4.                                 Thread.sleep(500);
   
5.                         }catch(InterruptedException e){
   
6.                                 e.printStackTrace();
   
7.                         }
   
8.                         if(flgs){
   
9.                                 flgs=false;
   
10.                                 synchronized(this){
    
11.                                         System.out.println(Thread.currentThread().getName()+"得到书了,现在想要画 A");
    
12.                                         synchronized(ThreadLock.class){
    
13.                                                 System.out.println(Thread.currentThread().getName()+"得到画了,现要想要书 B");
    
14.                                         }
    
15.                                 }
    
16.                         }
    
17.                         else{
    
18.                                 flgs=true;
    
19.                                 synchronized(ThreadLock.class){
    
20.                                         System.out.println(Thread.currentThread().getName()+"得到画了,现在想要书 C");
    
21.                                         synchronized(this){
    
22.                                                 System.out.println(Thread.currentThread().getName()+"得到书了,现要想要画 D");
    
23.                                         }
    
24.                                 }
    
25.                         }
    
26.                 }
    
27.         }

复制代码

恍然大悟呀，谢谢了

逻辑问题吧，while(true)位置应该不对吧，你放在if(flag)的外面来判断的话，那每次都会执行while里面的代码快了，要么去掉while循环，要么把while循环放在if(flag)里面进行判断。

李慧声 发表于 2013-4-1 00:09
逻辑问题吧，while(true)位置应该不对吧，你放在if(flag)的外面来判断的话，那每次都会执行while里面的代码 ...

跟while（true）没啥关系吧，关键是没有进行同步嵌套

同步死锁发生原因：
1，线程与线程之间共同处理共享的数据
2 . 锁中嵌套锁
你写死锁时往这两方面写，就会发生。
上海传智学员路过。。。。。。。

梁胜海 发表于 2013-4-1 10:52
同步死锁发生原因：
1，线程与线程之间共同处理共享的数据
2 . 锁中嵌套锁

谢谢，但是，你说的第一个原因“线程与线程之间共同处理共享的数据”，是死锁发生的原因吗？

刘海陆 发表于 2013-4-1 10:55
谢谢，但是，你说的第一个原因“线程与线程之间共同处理共享的数据”，是死锁发生的原因吗？ ...

是的，必须满足这两个条件就会发生死锁。但同步中也必须需要两个线程处理同一共享数据才叫同步。你想，两个线程都处理不同的数据，都运行自己的线程，跟同步即死锁搭不上边。

梁胜海 发表于 2013-4-1 10:58
是的，必须满足这两个条件就会发生死锁。但同步中也必须需要两个线程处理同一共享数据才叫同步。你想，两 ...

同步必须是两个线程处理同一个共享数据吗？ 我认为同步就是协同步骤，只要有两个包含两个以上线程，并且这几个线程都使用同一个锁就行了，难道一定要处理共享数据吗？？？

刘海陆 发表于 2013-4-1 11:04
同步必须是两个线程处理同一个共享数据吗？ 我认为同步就是协同步骤，只要有两个包含两个以上线程，并且 ...

你把你的代码一个锁放到另一个锁里面试试。
死锁发生的原因是：锁中的对象不一样，锁之间发生嵌套。

梁胜海 发表于 2013-4-1 11:31
你把你的代码一个锁放到另一个锁里面试试。
死锁发生的原因是：锁中的对象不一样，锁之间发生嵌套。 ...

嗯，就是同步中嵌套同步

刘海陆 发表于 2013-4-1 11:39
嗯，就是同步中嵌套同步

并且锁不一样

刘海陆 发表于 2013-4-1 10:05
跟while（true）没啥关系吧，关键是没有进行同步嵌套

对对对 没仔细看 应该是锁嵌套锁 这里根本就没有嵌套，我看成while了 呵呵