死锁概述，怎样会构成一个死锁

死锁是多线程，不当的使用synchronized嵌套发生的情况
每个对象的锁就一个，当两个线程去争夺这个锁时发生的情况

因为执行synchronized语句体的时候，线程会获取对象的锁，此时这个锁只有等到synchronized语句体执行完才会释放这个锁。

此时我们就想到，使用两个线程，去分别获取两个对象的锁，但要注意的是：获取的顺序必须相反，一个线程先获取对象1的锁，再获取对象2的锁，
另一个线程先获取对象2的锁，再获取对象1的锁。

下面是死锁的实现过程：

public class DeadLock{
    //验证死锁
    public static void main(String[] args) {
        Object obj0 = new Object();
        Object obj1 = new Object();//创建两个对象
        Thread t1 = new Thread1(obj0,obj1);
        Thread t2 = new Thread2(obj0,obj1);//创建两个线程对象
        //这两个线程对象虽然指向不同的对象
        //但是线程对象的，Object属性是相同的
        t1.start();
        t2.start();//分别启动线程
    }
}
class Thread1 extends Thread{
    Object o1 ;
    Object o2 ;
    public Thread1(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized(o1){ //先锁住o1
            try {  
            	//保证o1被这个线程占用
                Thread.sleep(1000);
            } catch (InterruptedException e) { }
            synchronized (o2){
                //因为下面o2锁被占了，这里的代码块执行不到
                //此时线程在疯狂寻找锁
            }
        }
    }
}
class Thread2 extends Thread{
    Object c1;
    Object c2;
    public Thread2(Object c1,Object c2){
        this.c1 = c1;
        this.c2 = c2;
    }
    public void run(){
        synchronized(c2){  //先锁住o2
            try {
            	//保证o2被线程占用
                Thread.sleep(1000);
            } catch (InterruptedException e) { }
            synchronized (c1){
                //因为上面o1锁被占了，这里的代码执行不到
                //此时线程2在疯狂寻找锁
            }
        }//结果就是程序一直僵持下去
    }//因为都没有找到彼此需要的锁
}

总结：
出现死锁时，我们不容易发现其中的原因
程序也不会报错，也不会出现异常
非常难调试，所以避免使用synchronized嵌套