关于死锁的问题，好多都不清楚呀？怎么产生的，怎么解决，好难

多线程的情况下，会出现死锁的现象。两个或两个以上线程会出现的情况
死锁呢就比如A，B两个线程，争夺资源的情况下A拿到B的锁。B拿到A的锁，出现的互相等待。

论坛内搜索：死锁

{:soso_e182:}

一般同步嵌套会出现死锁。也就是可能会出现线程之间抢锁的情况。
package multithread;

public class DeadLock1Test {

        public static void main(String[] args) {
                Thread t1 = new Thread(new DeadLock1(true));
                Thread t2 = new Thread(new DeadLock1(false));
               
                t1.start();
                t2.start();               
        }

}

class DeadLock1 implements Runnable {
        private boolean flase;

        public DeadLock1(boolean flase) {
                this.flase = flase;
        }
       
        public void run(){
                if(flase){
                        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");
                                        }
                                }
                        }
        }
}

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

死锁产生的多线程下共用同一个锁，因为同一个锁中的信息只能被一个锁执行，只有被释放后，其他的线程才能拿到锁，执行程序，
但是当锁中潜逃锁的话，那么锁匙交叉的嵌套的，就会可能产生死锁，但是不是一定会！

死锁的产生有四个必要条件;1，一个资源一次只能被一个进程使用，2，一个进程因请求资源而阻塞时，对已获得的资源保持不放，3，进程在已获得的资源，在没有使用完之前不强行剥夺,4,若干进程之间形成一种头尾相接，循环等待资源关系。希望对你有所帮助

死锁：是由同一个进程中的两个或者两个以上的线程，连个线程相互争夺使用锁，一个争夺锁，一个不放锁
就会产生死锁的情况，也会出现和谐的状态
死锁循环嵌套可以产生：
例如：

public class DeadLocalThread {

        public static void main(String[] args) throws Exception
        {
      new DeadDemo(true).start();
      new DeadDemo(false).start();
        }

}
class DeadDemo extends Thread
{      
         private boolean flag ;

        public DeadDemo(boolean flage)
        {
                this.flag=flag;
        }

        public void run()
        {    if(true==flag)
                {
                 while(true)
                 {
                         synchronized(MyLocal.la)
                         {
                                  System.err.println(Thread.currentThread().getName()+":::::mylocal.la");
                                  
                                  synchronized(MyLocal.lb)
                                 {
                                         System.err.println(Thread.currentThread().getName()+":::mylocal.lb");
                                 }
                         }
                 }
                }
        else
           {
                 while(true)
                 {
                         synchronized(MyLocal.lb)
                         {
                                  System.err.println(Thread.currentThread().getName()+":::mylocal.lb");
                                 synchronized(MyLocal.la)
                                 {
                                         System.err.println(Thread.currentThread().getName()+":::mylocal.la");
                                 }
                         }
                 }
           }
        }
       
}
class MyLocal
{
   static Object la= new Object();
    static Object lb =new Object();
}
希望对你有帮助

如果问题已解决，请将帖子改为提问结束，如果没有解决请楼主继续提问，谢谢合作

其实可以在看下毕老师的视频，产生死锁 ，我看完视频以后的理解是，两个线程互相持有锁，A线程需要B线程 和锁，B线程 需要A线程 的锁，两个线程之间需要对方的锁会，但是又不解锁，产生死锁。而且我记得sleep 睡的时候是不会释放锁资源。

如果问题已解决，请将帖子改为提问结束，如果没有解决请楼主继续提问，谢谢合作

楼主你好，如果问题已解决，请将帖子改为提问结束，如果没有解决请楼主继续提问，谢谢合作