java线程死锁

/**
* 死锁
* 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源释放才能继续而都进入阻塞状态，停止执行
* 同时拥有两个以上对象的锁时可能发生死锁
*/
public class TestThread2 implements Runnable{

   public static class LockA{}
   public static class LockB{}
   //创建两个类用于对象锁
   LockA lockA;
   LockB lockB;
   boolean aFirst;

   public TestThread2(LockA lockA, LockB lockB, boolean aFirst) {
       this.lockA = lockA;
       this.lockB = lockB;
       this.aFirst = aFirst;
   }

   @Override
   public void run() {
       if (aFirst){
           ab();
       }else {
           ba();
       }
   }

   public void ab(){
       synchronized(lockA){
           System.out.println(Thread.currentThread().getName()+"正在使用lockA");
           try {
               Thread.sleep(1);
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
           System.out.println(Thread.currentThread().getName()+"排队等待使用lockB");
           synchronized (lockB){
               //在同步代码内进行其他锁对象的同步
               System.out.println(Thread.currentThread().getName()+"正在使用lockB");
           }
       }
   }
   public void ba(){
       synchronized(lockB){
           System.out.println(Thread.currentThread().getName()+"正在使用lockB");
           try {
               Thread.sleep(1);
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
           System.out.println(Thread.currentThread().getName()+"排队等待使用lockA");
           synchronized (lockA){
               //在同步代码内进行其他锁对象的同步
               System.out.println(Thread.currentThread().getName()+"正在使用lockA");
           }
       }
   }

   public static void main(String[] args) {
       LockA lockA = new LockA();
       LockB lockB = new LockB();
       Thread t1 = new Thread(new TestThread2(lockA,lockB,true));
       Thread t2 = new Thread(new TestThread2(lockA,lockB,false));
       t1.start();
       t2.start();
       /*结果为
       Thread-1正在使用lockB
       Thread-0正在使用lockA
       Thread-1排队等待使用lockA
       Thread-0排队等待使用lockB

       T-1等待T-0释放lockA而阻塞，T-0等待T-1释放lockB而阻塞形成死锁

       java中没有专用的解决办法，因此编程时禁止使用synchronized相互嵌套
        */
   }
}