麻烦大家给看看我这个死锁的程序的写的对不对啊，我感觉没什么错误啊，可是为什么每次的执行结果都相同啊，执行了n次打印出来的结果一模一样
class DeadLock implements Runnable {
    public boolean flag = true;
    public void run() {
        if(flag) {
            while(true) {
                synchronized(Lock.locka) {
                    System.out.println(Thread.currentThread().getName()+"iflocka");
                    synchronized(Lock.lockb) {
                        System.out.println(Thread.currentThread().getName()+"iflockb");
                    }   
                }               
            }
        } else {
            while(true) {
                synchronized(Lock.lockb) {
                    System.out.println(Thread.currentThread().getName()+"........lockb");
                    synchronized(Lock.locka) {
                        System.out.println(Thread.currentThread().getName()+".........locka");
                    }   
                }               
            }
        }
    }
}

class Lock {
    public static Object locka = new Object();
    public static Object lockb = new Object();
}

public class DeadLockTest1 {
    public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        Thread t1 = new Thread(dl);
        Thread t2 = new Thread(dl);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dl.flag = false;
        t2.start();
    }
}
死锁这块弄一晚上了，麻烦明白的学哥学姐给俺讲讲，谢谢...

在多线程中线程启动后，cpu资源的分配是随机的，可能你执行100次都会是一样的，这没什么的。但是清楚死锁的概念就好了
即一组线程都持有资源，并且等待线程中其他线程的资源。
满足一下四点死锁就会发生：
互斥：一次只有一个线程可以使用一个资源
占有并等待：一个至少持有一个资源的线程等待获得有其他线程所持有的资源
非抢占：一个线程只有等到其执行完之后才会自动释放。
循环等待：等待资源之间存在环
记住以上几点就可以了！

史小兵 发表于 2012-9-17 20:44
在多线程中线程启动后，cpu资源的分配是随机的，可能你执行100次都会是一样的，这没什么的。但是清楚死锁的 ...

那我写的那个应该是没错是吧？

知道理论后，下面的代码就很好写了

1. class ThreadA extends Thread {
   
2.         private Object x;
   
3.         private Object y;
   
4. 
   
5.         public ThreadA(Object x, Object y) {
   
6.                 this.x = x;
   
7.                 this.y = y;
   
8.         }
   
9. 
   
10.         @Override
    
11.         public void run() {
    
12.                 while (true) {
    
13.                         synchronized (x) {
    
14.                                 System.out.println("ThreadB 以获取x。。。。");
    
15.                                 try {
    
16.                                         sleep(3000);
    
17.                                 } catch (InterruptedException e) {
    
18.                                         e.printStackTrace();
    
19.                                 }
    
20.                                 System.out.println("ThreadA 正请求y:");
    
21.                                 synchronized (y) {
    
22.                                         System.out.println("ThreadA 以获取y。。。。");
    
23.                                 }
    
24.                                 System.out.println("ThreadA 释放y,,,,");
    
25.                         }
    
26.                         System.out.println("ThreadA 释放x,,,,");
    
27.                 }
    
28. 
    
29.         }
    
30. }
    
31. 
    
32. class ThreadB extends Thread {
    
33.         private Object x;
    
34.         private Object y;
    
35. 
    
36.         public ThreadB(Object x, Object y) {
    
37.                 this.x = x;
    
38.                 this.y = y;
    
39.         }
    
40. 
    
41.         @Override
    
42.         public void run() {
    
43.                 while (true) {
    
44.                         synchronized (y) {
    
45.                                 System.out.println("ThreadB 以获取y。。。。");
    
46.                                 try {
    
47.                                         sleep(3000);
    
48.                                 } catch (InterruptedException e) {
    
49.                                         e.printStackTrace();
    
50.                                 }
    
51. 
    
52.                                 System.out.println("ThreadB 正请求x:");
    
53.                                 synchronized (x) {
    
54.                                         System.out.println("ThreadB 以获取x。。。。");
    
55.                                 }
    
56.                                 System.out.println("ThreadB 释放x,,,,");
    
57.                         }
    
58.                         System.out.println("ThreadB 释放y,,,,");
    
59.                 }
    
60.         }
    
61. }
    
62. 
    
63. public class DeadLock {
    
64.         public static void main(String[] args) {
    
65.                 // 建立两个对象锁
    
66.                 Object x = new Object();
    
67.                 Object y = new Object();
    
68.                
    
69.                 // ThreadA先获取x，然后获取y
    
70.                 new ThreadA(x, y).start();
    
71.                
    
72.                 // ThreadA先获取y，然后获取x
    
73.                 new ThreadB(x, y).start();
    
74.                
    
75.                 // synchronized关键字获取对象时，如果没有获取会一直等待查询，知道获取
    
76.         }
    
77. }
    

复制代码

我就是纳闷，难道我真就那么悲剧....

嗯，应该没问题的！或者你可以把sleep时间改的长一点试试就知道了

class DeadLock implements Runnable {
    public boolean flag = true;
    public void run() {
        if(flag) {
            while(true) {
                synchronized(Lock.locka) {
                    System.out.println(Thread.currentThread().getName()+"iflocka");
                   try {
                                                Thread.currentThread().sleep(1000);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }                    synchronized(Lock.lockb) {
                        System.out.println(Thread.currentThread().getName()+"iflockb");
                    }   
                }               
            }
        } else {
            while(true) {
                synchronized(Lock.lockb) {
                    System.out.println(Thread.currentThread().getName()+"........lockb");
                    try {
                                                Thread.currentThread().sleep(1000);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }                    synchronized(Lock.locka) {
                        System.out.println(Thread.currentThread().getName()+".........locka");
                    }   
                }               
            }
        }
    }
}

class Lock {
    public static Object locka = new Object();
    public static Object lockb = new Object();
}

public class test {
    public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        Thread t1 = new Thread(dl);
        Thread t2 = new Thread(dl);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dl.flag = false;
        t2.start();
    }
}

1. class DeadLock implements Runnable {
   
2.              public boolean flag = true;
   
3.              DeadLock(boolean flag)//直接在构造函数这里设置标记
   
4.              {
   
5.                      this.flag = flag;
   
6.              }
   
7.              public void run() {
   
8.                  if(flag) {
   
9.                      while(true) {
   
10.                          synchronized(Lock.locka) {
    
11.                              System.out.println(Thread.currentThread().getName()+"iflocka");
    
12.                              synchronized(Lock.lockb) {
    
13.                                  System.out.println(Thread.currentThread().getName()+"iflockb");
    
14.                              }   
    
15.                         }               
    
16.                     }
    
17.                  } else {
    
18.                      while(true) {
    
19.                          synchronized(Lock.lockb) {
    
20.                              System.out.println(Thread.currentThread().getName()+"........lockb");
    
21.                              synchronized(Lock.locka) {
    
22.                                  System.out.println(Thread.currentThread().getName()+".........locka");
    
23.                              }   
    
24.                         }               
    
25.                     }
    
26.                  }
    
27.              }
    
28.          }
    
29.          
    
30.         class Lock {
    
31.              public static Object locka = new Object();
    
32.              public static Object lockb = new Object();
    
33.          }
    
34.          
    
35.         public class DeadLockTest{
    
36.              public static void main(String[] args) {
    
37.                  Thread t1 = new Thread(new DeadLock(true));
    
38.                  Thread t2 = new Thread(new DeadLock(false));
    
39.                  t1.start();//这样t1,t2会同时去抢执行权，t1抢到a锁后，t2也拿到了b锁，然后才能发生死锁
    
40.                  t2.start();
    
41.              }
    
42.          }

复制代码