用通俗的话来说就是张三跟李四下饭馆吃饺子，张三拿着醋，李四拿着蒜瓣，张三说李四你给我吃点蒜，李四说，那不行，你得先给我醋，要不然我不给你，张三也不乐意了，说你必须先给我蒜瓣，我再给你醋，这种现象就是死锁。（Dead Lock）

官方一点说就是：

指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。产生死锁的原因，主要包括：
系统资源不足；
程序执行的顺序有问题；
资源分配不当等。
如果系统资源充足，进程的资源请求都能够得到满足，那么死锁出现的可能性就很低；否则，就会因争夺有限的资源而陷入死锁。其次，程序执行的顺序与速度不同，也可能产生死锁。

Java中的死锁指的是线程死锁，

线程死锁是线程在满足一定条件的情况下才会执行，但是这个满足的条件是矛盾的，线程资源无法抢占使用

比如线程二的执行条件是线程一执行完毕，而线程一的执行条件是要线程二执行到某一步骤时执行

Java中的死锁当两个线程永远等待对方意味着(即没有机会进入就绪队列)时，这种无限等待类型称为死锁。

当等待进程仍保留第一个需要完成的另一个资源时，就会发生死锁。

通过使用synced关键字，我们可能会陷入僵局。不建议将Synchronize关键字不必要地应用。

我们无法解决僵局，但可以基于几种技术来避免出现僵局。

我们如何分析僵局情况？如果所有线程只有一个对象，那么我们可以使用一个称为“等待图形”的图形。

如果一个线程有多个对象作为一个周期，那么等待图形将无法正常工作，那么我们应该在操作系统中寻求类似banker算法的解决方案来检测死锁。

在给定的示例中，下面我们将看到死锁的情况：

示例class HelloClass{

public synchronized void first(HiClass hi)

{

try{

Thread.sleep(1000);

}

catch(InterruptedException ie){}

System.out.println(" HelloClass is calling HiClass second() method");

hi.second();

}

public synchronized void second(){

System.out.println("I am inside second method of HelloClass");

}

}

class HiClass{

public synchronized void first(HelloClass he)

{

try{

Thread.sleep(1000);

}

catch(InterruptedException ie){}

System.out.println(" HiClass is calling HelloClass second() method");

he.second();

}

public synchronized void second(){

System.out.println("I am inside second method of HiClass");

}

}

class DeadlockClass extends Thread{

HelloClass he = new HelloClass();

HiClass hi = new HiClass();

public void demo(){

this.start();

he.first(hi);

}

public void run(){

hi.first(he);

}

public static void main(String[] args){

DeadlockClass dc = new DeadlockClass();

dc.demo();

}

}

输出结果D:\Java Articles>java DeadlockClass

HelloClass is calling HiClass second() method

HiClass is calling HelloClass second() method

Java中的死锁当两个线程永远等待对方意味着(即没有机会进入就绪队列)时，这种无限等待类型称为死锁。

当等待进程仍保留第一个需要完成的另一个资源时，就会发生死锁。

通过使用synced关键字，我们可能会陷入僵局。不建议将Synchronize关键字不必要地应用。

我们无法解决僵局，但可以基于几种技术来避免出现僵局。

在计算机系统中，涉及软件，硬件资源都可能发生死锁。例如：系统中只有一台CD-ROM驱动器和一台打印机，某一个进程占有了CD-ROM驱动器，又申请打印机；另一进程占有了打印机，还申请CD-ROM。结果，两个进程都被阻塞，永远也不能自行解除。
 所谓死锁，是指多个进程循环等待它方占有的资源而无限期地僵持下去的局面。很显然，如果没有外力的作用，那麽死锁涉及到的各个进程都将永远处于封锁状态。

死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

java 死锁产生的四个必要条件：

• 1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

• 2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

• 3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

• 4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

在多线程程序中，使用了多把锁，造成线程之间相互等待，程序不往下走了，就是死锁；

死锁的条件：有多把锁，有多个线程，有同步代码块嵌套；

Java 实例：

public class Test {

    public static void main(String[] args) {

        MyRunnable mr = new MyRunnable();

        new Thread(mr).start();

        new Thread(mr).start();

    }

}

class MyRunnable implements Runnable {

    Object objA = new Object();

    Object objB = new Object();

    /*

    嵌套1 objA

    嵌套1 objB

    嵌套2 objB

    嵌套1 objA

    */

    @Override

    public void run() {

        synchronized (objA) {

            System.out.println("嵌套1 objA");

            synchronized (objB) {//t2, objA, 拿不到B锁,等待

                System.out.println("嵌套1 objB");

            }

        }

        synchronized (objB) {

            System.out.println("嵌套2 objB");

            synchronized (objA) {//t1, objB, 拿不到A锁,等待

                System.out.println("嵌套2 objA");

            }

        }

    }

}

/*

输出

嵌套1 objA

嵌套1 objB

嵌套2 objB

嵌套1 objA

...

 */

————————————————

死锁是一种特定的程序状态，在实体之间，由于循环依赖导致彼此一直处于等待之中，没有任何个体可以继续前进。死锁不仅仅会发生在线程之间，存在资源独占的进程之间同样也可能出现死锁。通常来说，我们大多是聚焦在多线程场景中的死锁，指两个或多个线程之间，由于互相持有对方需要的锁，而永久处于阻塞的状态。