史上超级无敌多线程死锁

 *  synchronized:并不是往对象里面枷锁,锁是每个对象都有的属性,synchronized只是锁上了这把锁,是个持续的动作而已
 *  死锁就是大家都访问不了的状态
 *
 *  两个线程,
 *  两个线程先后访问两个互斥的对象
 *
 *  原理:
 *      1某个线程执行完成,需要 先后 嵌套 锁定 执行两个对象,但是,过程当中,肯定就锁定了第一个对象
 *      2 另外一个线程执行完成,也需要先后嵌套锁定执行两个对象,先执行锁定第二个对像
 *      3 在第一个执行过程中,执行到第二个对象时,发现被锁定了,等待
 *      4 第二个线程执行过程中,执行到第一个对象的时候,发现第一个被锁死了,也只能等待.

public class Thread DeadLock{
    public static void main(String[] args){
        Object o1 = new Object();
        Object o2 = new Object();

        Thread t1 = new Thread(new A(o1,o2));
        Thread t2 = new Thread(new B(o1,o2));
        t1.start();
        t2.start();
    }
}

class A implements Runnable{
    Object o1;
    Object o2;

    T1(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run(){
        synchronized(o1){
            try{
                Thread.sleep(1000);
            }catch(Exception e){
                e.PRintStackTrace();
            }
            synchronized(o2){
                System.out.println( "t1" );
            }
        }
    }
}

class B implements Runnable{
    Object o1;
    Object o2;

    T2(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run(){
        synchronized(o2){
            try{
                Thread.sleep(1000);
            }catch(Exception e){
                e.printStackTrace();
            }
            synchronized(o1){
                System.out.println( "t2" );
            }
        }
    }
}