在 Java 中，死锁是一种情况，其中至少有两个线程持有某个不同资源的锁，并且都在等待其他资源完成其任务。

而且，没有人能够对其持有的资源保持锁定。

例如，下面的例子中， 线程-1有A但需要B来完成处理，类似的线程-2有资源B但首先需要A。

package thread;
public class ResolveDeadLockTest {
	public static void main(String[] args) {
		ResolveDeadLockTest test = new ResolveDeadLockTest();
		final A a = test.new A();
		final B b = test.new B();
		// Thread-1
		Runnable block1 = new Runnable() {
			public void run() {
				synchronized (a) {
					try {
						// 添加延迟以便两个线程都可以开始尝试锁定资源
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					// Thread-1 持有A资源 但在等待B资源
					synchronized (b) {
						System.out.println("In block 1");
					}
				}
			}
		};
		// Thread-2
		Runnable block2 = new Runnable() {
			public void run() {
				synchronized (b) {
					// Thread-2 持有B资源 但在等待A资源
					synchronized (a) {
						System.out.println("In block 2");
					}
				}
			}
		};
		new Thread(block1).start();
		new Thread(block2).start();
	}
	// Resource A
	private class A {
		private int i = 10;
		public int getI() {
			return i;
		}
		public void setI(int i) {
			this.i = i;
		}
	}
	// Resource B
	private class B {
		private int i = 20;
		public int getI() {
			return i;
		}
		public void setI(int i) {
			this.i = i;
		}
	}
}

如何避免死锁

我相信，解决任何问题的方法都在于找出问题的根源。
在我们的例子中，访问资源 A和 B的模式是主要问题。
因此，为了解决它，我们将简单地重新排序代码访问共享资源的语句。

// Thread-1
	Runnable block1 = new Runnable() {
		public void run() {
			synchronized (b) {
				try {
					// 添加延迟以便两个线程都可以开始尝试锁定资源
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// Thread-1 持有A资源 但在等待B资源
				synchronized (a) {
					System.out.println("In block 1");
				}
			}
		}
	};
	// Thread-2
	Runnable block2 = new Runnable() {
		public void run() {
			synchronized (b) {
				// Thread-2 持有B资源 但在等待A资源
				synchronized (a) {
					System.out.println("In block 2");
				}
			}
		}
	};