最好用代码体现!

1. public class DeadLock implements Runnable {
   
2. 
   
3.         boolean flag;
   
4.         public DeadLock(boolean flag) {
   
5.                 this.flag = flag;
   
6.         }
   
7.         //相互持锁,互不释放,产生死锁
   
8.         public void run() {
   
9.                 while(true){
   
10.                         if(flag){
    
11.                                 synchronized(MyLock.lock1){
    
12.                                         System.out.println("true lock1");
    
13.                                         synchronized (MyLock.lock2) {
    
14.                                                 System.out.println("false lock2");
    
15.                                         }
    
16.                                 }       
    
17.                         }else{
    
18.                                 synchronized(MyLock.lock2){
    
19.                                         System.out.println("false lock2");
    
20.                                         synchronized(MyLock.lock1){
    
21.                                                 System.out.println("false lock1");
    
22.                                         }
    
23.                                 }
    
24.                         }
    
25. 
    
26.                 }
    
27.                
    
28.         }
    
29. }

复制代码

1. public class DieLock extends Thread {
   
2.         private boolean flag;
   
3.         public DieLock(boolean flag)//提供构造函数
   
4.         {
   
5.                 this.flag=flag;
   
6.         }
   
7.         //重写run方法
   
8.         public void run()
   
9.         {
   
10.                 if(flag)//根据DieLockDemo生成的俩个线程，flag有两个值
    
11.                 {
    
12.                         synchronized(MyLock.objA)//线程A进来了
    
13.                         {
    
14.                                 System.out.println("if ObjA");
    
15.                                 //此时需要线程B的锁
    
16.                                 synchronized (MyLock.objB) {
    
17.                                         System.out.println("if ObjB");
    
18.                                        
    
19.                                 }
    
20.                         }
    
21.                 }
    
22.                 else
    
23.                 {
    
24.                         synchronized(MyLock.objB)//线程B进来了
    
25.                         {
    
26.                                 System.out.println("else ObjA");
    
27.                                 //此时需要线程A的锁
    
28.                                 synchronized (MyLock.objA) {
    
29.                                         System.out.println("else ObjB");
    
30.                                        
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.         }
    
35. 
    
36. }
    
37. public class DieLockDemo {
    
38.         public static void main(String[] args) {
    
39.                 //建立两个个线程
    
40.                 DieLock d1=new DieLock(true);
    
41.                 DieLock d2=new DieLock(false);
    
42.                 d1.start();
    
43.                 d2.start();
    
44.                
    
45.         }
    
46.        
    
47. }
    
48. public class MyLock {
    
49.         //生成两个锁对象
    
50.       public static final Object objA=new Object();
    
51.       public static final Object objB=new Object();
    
52. }
    

复制代码

就好比，你有两个抽屉A,B，A的钥匙锁在B抽屉里，B的钥匙锁在A抽屉里面，这不就死锁了吗

死锁就是两个线程互相等待 A线程在等待B线程执行结束 B线程在等待A线程执行结束 互相等待 然后永远等不完

喔哦~~这么一看，顿时茅塞顿开呀，谢谢

大概就是你的不给我，我的不给你，然后就僵在那里了

学习了！！！

Java线程死锁是一个经典的多线程问题，因为不同的线程都在等待那些根本不可能被释放的锁，从而导致所有的工作都无法完成。假设有两个线程，分别代表两个饥饿的人，他们必须共享刀叉并轮流吃饭。他们都需要获得两个锁：共享刀和共享叉的锁。
假如线程 “A”获得了刀，而线程“B”获得了叉。线程“A”就会进入阻塞状态来等待获得叉，而线程“B”则阻塞来等待“A”所拥有的刀。这只是人为设计的例子，但尽管在运行时很难探测到，这类情况却时常发生。
导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。
避免死锁的一个通用的经验法则是:当几个线程都要访问共享资源A、B、C时，保证使每个线程都按照同样的顺序去访问它们，比如都先访问A，在访问B和C。
  此外，Thread类的suspend()方法也很容易导致死锁,因此这个方法已经被废弃了.

我感觉这个好难哦，继续努力

代码：
/*
需求：
死锁来一发

*/

class DeadLockDemo2
{
        public static void main(String[] args) throws InterruptedException
        {
                Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));

                t1.start();
                t1.sleep(10);
                t2.start();
        }
       
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}

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

class Test implements Runnable
{
        private boolean flag;

        Test(boolean flag)
        {
                this.flag = flag;
        }

        public void run()
        {
                if (flag == true)
                {
                        while (true)
                        {
                                synchronized(MyLock.locka)
                                {
                                        sop("true&locka");
                                        synchronized(MyLock.lockb)
                                        {
                                                sop("true&lockb");
                                        }
                                }
                        }
                }
                else
                {
                        while (true)
                        {
                                synchronized(MyLock.lockb)
                                {
                                        sop("false&lockb");
                                        synchronized(MyLock.locka)
                                        {
                                                sop("false&locka");
                                        }
                                }
                        }
                }
        }

        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}

死锁的意思是：
在两条线程都持有一个锁 而且程序运行都需要对方的锁的时候 程序就会卡住

这是当出现同步嵌套的时候 可能会出现的一种情况
因为可能出现一方将两个锁都用完 然后cpu执行权被另一方抢到的情况 所以同步嵌套只是前提 不是发生死锁的必要条件