一直在看毕老师的视频，但看到死锁这块就有点晕，有几个问题实际操作时一直不通，感觉还是有些不理解。哪位大神可否给我讲讲：死锁是如何造成的？怎样避免死锁？尽量举现实中的例子，形象点就行。（主要说点原理）
谢谢！！！！

死锁怎么避免，你不要写死锁的代码就可以了啊，死锁是多线程同步中的特殊代码，不写不就避免了。
死锁的专业解释:
多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
看这个还是挺晕的，举现实中的例子：比如你和你朋友去吃饭喝酒去了，这个时候你说哥们去上个厕所，你朋友说去吧，然后你就去了，进的是1号坑，这个时候厕所的门是开着的，必须开着不是，然后你进去就开始嘘嘘，然后把门锁上了(A锁)，但是你的出口没有锁上，也就是b锁还是开着的，这个时候你的朋友也来上厕所了，也喝多了不是？他一进厕所，把门锁上了也就是b锁，你的出口的锁是和他进来的锁一样的，得他把门锁上了你就出不去了，而他的二号坑的出口锁和你的进口锁一样，都是a锁，也锁上了，然后你就发现你们两个都被锁到厕所里了，不知道这个理解没，画了个超级简单的图，清晰点

举一个简单的例子，比如有一个通道，通道两端有两扇门，分别为A门和B门，A门和B门分别有唯一的A锁和B锁，有甲乙两个人，甲的工作是不断的拿到A锁从A门进，再拿到B锁从B门出，乙的工作是不断的拿到B锁从B门进，再拿到A锁从A门出，当甲从A门进，再从B门出来以后，乙再从B门进，A门出来后，甲再从A门进，B门出，周而复始，可以相安无事，然而难免有一次，甲从A门进来后，同时乙从B门进来了，这时甲要从B门出就要用到乙从B门拿到的锁，同理，这时乙要从A门出就要用到甲从A门拿到的锁，两人谁都不把自己的锁交给对方，相持不下，形成了死锁。

A线程占有A资源（A锁）
B线程占有B资源（B锁）
这时A线程要用B资源，（B资源被A线程占用）
B线程要用A资源，（A资源被B线程占用）
就出现了A线程占有A资源（A锁），等待B资源（B锁）
就出现了B线程占有B资源（B锁），等待A资源（A锁）
有点绕口令的感觉{:soso_e120:}

所谓死锁： 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。

举个简单的例子:
有3个人吃饭,每人需要拿到2根筷子才能吃饭,一共有3根筷子
如果其中一个人先拿到2根,那他吃完饭后释放资源,把他的筷子贡献出来,剩下的两个人抢3根筷子,肯定有1个拿到两根,这样循环,3个人都能吃饱

但是如果每个人都只拿到1根筷子,同时他们又不愿意释放自己所拥有的资源
这样3个人就僵持住,一个也吃不到饭
这就是死锁

死锁有4个必要条件
1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。 (当一个人拿到两根筷子,在吃饭的时候,另外两个只能看着)
　　
2）请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。(比如:已拿到1根筷子,但是另外两根分别在两个人手中,所以请求进程阻塞,但是又不放开已拿到手的筷子) 　
　
3）不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。 (当一个人拿到筷子,只能等他吃饱饭,才会把筷子贡献出去,不能被强制剥夺)
　　
4）环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链(必须是环路,比如两个人,a需要b的筷子,b也需要a的筷子)

处理死锁的基本方法:
1) 预防死锁 通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。
2) 避免死锁 在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免发生死锁

synchronized(生产锁)
{
synchronized(消费锁)
{
  if()
   生产wait();

}

}
synchronized(消费锁)
{
synchronized(生产锁)
{
  if()
   消费的wait();
  ....;
  生产的notify生产();
}
}
当线程1用生产锁进如生产后，没等释放了锁线程2进如消费锁进行消费，而等消费完了没等释放锁
线程1有需要消费，但是没有锁所以就会死锁，生产锁也是一样没拿到锁就会发生死锁

容易引发死锁的情况之一：同步的嵌套
为什么是object 中的方法呢？因为这些方法都是必须要标识出来所属的锁。而锁是任意的对象，能被任意对象所访问到的对象，应该是在使用等待唤醒时都需要标记。flag等待唤醒机制中，最常见的体现就是生产者和消费者问题。当多生产多消费者同时出现时，用while做判断，并且用notifyAll来唤醒，此时唤醒中肯定有对方。但是这个只适合单生产者和单消费者，当面对多生产者和多消费者的时候有无法保证了。
等待唤醒机制中，最常见的体现就是生产者消费者问题,发现两个问题：
1，出现了错误的数据。是因为多生产和多消费的时候，被唤醒的线程没有再次判断标记就执行了。解决是将if判断变成while判断。
2，发现有了while判断后，死锁了。因为本方线程唤醒的有可能还是本方线程。所以导致了死锁。解决：本方必须唤醒对方才有效。notify只能唤醒一个，还不确定。所以干脆唤醒全部，肯定包含对方，至于被唤醒的本方，会判断标记是否继续等待。
class Test implements Runnable
{
private boolean flag = true;
Test(boolean flag)
{
this.flag = flag;
}
public void run()
{
while(true)
{
if(flag)
{
synchronized(MyLock.lock_a)
{
System.out.println(Thread.currentThread().getName()+"..if lock_a");
synchronized(MyLock.lock_b)
{
System.out.println(Thread.currentThread().getName()+"..if lock_b");
}
}
}
else
{
synchronized(MyLock.lock_b)
{
System.out.println(Thread.currentThread().getName()+"..else  lock_b");
synchronized(MyLock.lock_a)
{
System.out.println(Thread.currentThread().getName()+"..else  lock_a");
}
}
}
}
}
}
class MyLock
{
public static Object lock_a = new Object();
public static Object lock_b = new Object();
}
class  DeadLockTest
{
public static void main(String[] args)
{
Test t1 = new Test(true);
Test t2 = new Test(false);
new Thread(t1).start();
new Thread(t2).start();
}
}

如果是同一个应用程序需要并行处理多件任务，那就可以创建多条线程。但是人多了，往往会出现冲突，使得这个工作无法再进行下去了，（三个和尚没水喝！）这就是“死锁”。
形象的例子：A、B、C三个人(相当于三个线程)在玩三个球，规则是每个人必须先拿到自己左手边的球，才能拿自己右边的球，两手都有球后，才能把球都放下。
如果三个人恰巧都拿到左手边的球，一起等着拿右手的球。这时A、B、C三个线程就会一直等待。这就可以看成死锁