1. class MyLock
   
2.         {
   
3.                 static Object locka = new Object();
   
4.                 static Object lockb = new Object();
   
5.         }
   
6. class Test implements Runnable
   
7. {
   
8.         private boolean flag;
   
9.         Test(boolean flag)
   
10.                 {
    
11.                 this.flag = flag;
    
12.                 }
    
13.         public void run()
    
14.                 {
    
15.                         if (flag)
    
16.                                 {
    
17.                                 while(true)
    
18.                                         {
    
19.                                         synchronized (MyLock.locka)
    
20.                                                 {
    
21.                                                 System.out.println("......if locka ");
    
22.                                                 synchronized (MyLock.lockb)
    
23.                                                         {
    
24.                                                         System.out.println(".......if lockb");
    
25.                                                         }
    
26.                                                 }
    
27.                                         }
    
28.                                 }
    
29.                         else
    
30.                         {
    
31.                                 while (true)
    
32.                                 {
    
33.                                         synchronized (MyLock.lockb)
    
34.                                                 {
    
35.                                                         System.out.println("......else lockb");
    
36.                                                         synchronized(MyLock.locka)
    
37.                                                                 {
    
38.                                                                         System.out.println(".....else locka");
    
39.                                                                 }
    
40.                                                 }
    
41.                                 }
    
42.                         }
    
43.                 }
    
44. }
    
45. public class DeadLockTest
    
46.         {
    
47.         public static void main(String[] args)
    
48.                 {
    
49.                 Thread t1 = new Thread(new Test(true));
    
50.                 Thread t2 = new Thread(new Test(false));
    
51.                 t1.start();
    
52.                 t2.start();
    
53.                 }
    
54.         }

复制代码

题目是毕老师视频里的。我听了两遍没有太明白。比如调用flag。问问同学，有没有纤细的解说步骤，简单易懂点。谢谢咯！给好心人送花花。

class MyLock
        {        //创建了两个锁对象,只要是个对象就可以做锁,这里创建了两个object对象
                static Object locka = new Object();
                static Object lockb = new Object();
        }
class Test implements Runnable
{       
        //构造方法里面就需要传入一个falg boolean标记
        private boolean flag;
        Test(boolean flag)
                {
                this.flag = flag;
                }
        public void run()
                {
                        if (flag) //假如标记为真,进来
                                {
                                while(true)
                                        {
                                        synchronized (MyLock.locka) //上第一个锁对象
                                                {
                                                System.out.println("......if locka ");
                                                synchronized (MyLock.lockb) //上第二个锁对象
                                                        {
                                                        System.out.println(".......if lockb");
                                                        }
                                                }
                                        }
                                }
                        else//假如标记为假,
                        {
                                while (true)
                                {
                                        synchronized (MyLock.lockb) //上第二个锁对象
                                                {
                                                        System.out.println("......else lockb");
                                                        synchronized(MyLock.locka) //上第一个锁对象
                                                                {
                                                                        System.out.println(".....else locka");
                                                                }
                                                }
                                }
                        }
                }
}
public class DeadLockTest
        {
        public static void main(String[] args)
                {
                Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));
                t1.start();
                t2.start();
                }
        }

两个锁对象,互相持有对方的引用,都同步,所以造成死锁的现象

两个锁用不同的对象，0线程true，1线程false都不断执行锁循环，最外层的锁还不一样。当0线程执行完a锁要执行b锁的时候，恰好1线程的b锁还没执行完。0线程 就等着1线程释放b锁。1锁执行完b锁又要获得a锁，但是这是0线程还持有a锁。就是死循环。叫死锁

我知道了，刚刚看了下面一个死锁的视频也是一样的，我没有理解if（flag）为真为啥会是真就可以进，呵呵。其他的点都可以明白，我自己也再多写了几遍程序了。哈哈。谢谢同学。:handshake

fenzheng 发表于 2014-5-30 17:09
两个锁对象,互相持有对方的引用,都同步,所以造成死锁的现象

自己弄懂了，谢谢同学

丁绍然 发表于 2014-5-30 19:01
两个锁用不同的对象，0线程true，1线程false都不断执行锁循环，最外层的锁还不一样。当0线程执行完a锁要执 ...

懂了，谢谢你:handshake