*  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" );
            }
        }
    }
}