死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。
例如，如果线程1锁住了a，然后尝试对b进行加锁，同时线程2已经锁住了b，接着尝试对a进行加锁，这时死锁就发生了。线程1永远得不到b，线程2也永远得不到a，并且它们永远也不会知道发生了这样的事情。为了得到彼此的对象（a和b），它们将永远阻塞下去。这种情况就是一个死锁。
该情况如下：
thread 1 locks a, waits for b
thread 2 locks b, waits for a这里有一个treenode类的例子，它调用了不同实例的synchronized方法：
public class treenode {
treenode parent = null;
list children = new arraylist();
public synchronized void addchild(treenode child){
if(!this.children.contains(child)) {
this.children.add(child);
child.setparentonly(this);
}
}
public synchronized void addchildonly(treenode child){
if(!this.children.contains(child){
this.children.add(child);
}
}
public synchronized void setparent(treenode parent){
this.parent = parent;
parent.addchildonly(this);
}
public synchronized void setparentonly(treenode parent){
this.parent = parent;
}
}如果线程1调用parent.addchild(child)方法的同时有另外一个线程2调用child.setparent(parent)方法，两个线程中的parent表示的是同一个对象，child亦然，此时就会发生死锁。下面的伪代码说明了这个过程：
thread 1: parent.addchild(child); //locks parent
--> child.setparentonly(parent);
thread 2: child.setparent(parent); //locks child
--> parent.addchildonly()首先线程1调用parent.addchild(child)。因为addchild()是同步的，所以线程1会对parent对象加锁以不让其它线程访问该对象。
然后线程2调用child.setparent(parent)。因为setparent()是同步的，所以线程2会对child对象加锁以不让其它线程访问该对象。
现在child和parent对象被两个不同的线程锁住了。接下来线程1尝试调用child.setparentonly()方法，但是由于child对象现在被线程2锁住的，所以该调用会被阻塞。线程2也尝试调用parent.addchildonly()，但是由于parent对象现在被线程1锁住，导致线程2也阻塞在该方法处。现在两个线程都被阻塞并等待着获取另外一个线程所持有的锁。
注意：像上文描述的，这两个线程需要同时调用parent.addchild(child)和child.setparent(parent)方法，并且是同一个parent对象和同一个child对象，才有可能发生死锁。上面的代码可能运行一段时间才会出现死锁。
这些线程需要同时获得锁。举个例子，如果线程1稍微领先线程2，然后成功地锁住了a和b两个对象，那么线程2就会在尝试对b加锁的时候被阻塞，这样死锁就不会发生。因为线程调度通常是不可预测的，因此没有一个办法可以准确预测什么时候死锁会发生，仅仅是可能会发生。
更复杂的死锁
死锁可能不止包含2个线程，这让检测死锁变得更加困难。下面是4个线程发生死锁的例子：
thread 1 locks a, waits for b
thread 2 locks b, waits for c
thread 3 locks c, waits for d
thread 4 locks d, waits for a线程1等待线程2，线程2等待线程3，线程3等待线程4，线程4等待线程1。
数据库的死锁
更加复杂的死锁场景发生在数据库事务中。一个数据库事务可能由多条sql更新请求组成。当在一个事务中更新一条记录，这条记录就会被锁住避免其他事务的更新请求，直到第一个事务结束。同一个事务中每一个更新请求都可能会锁住一些记录。
当多个事务同时需要对一些相同的记录做更新操作时，就很有可能发生死锁，例如：
transaction 1, request 1, locks record 1 for update
transaction 2, request 1, locks record 2 for update
transaction 1, request 2, tries to lock record 2 for update.
transaction 2, request 2, tries to lock record 1 for update.因为锁发生在不同的请求中，并且对于一个事务来说不可能提前知道所有它需要的锁，因此很难检测和避免数据库事务中的死锁。
在有些情况下死锁是可以避免的。本文将展示三种用于避免死锁的技术：
加锁顺序
加锁时限
死锁检测
加锁顺序
当多个线程需要相同的一些锁，但是按照不同的顺序加锁，死锁就很容易发生。
如果能确保所有的线程都是按照相同的顺序获得锁，那么死锁就不会发生。看下面这个例子：
thread 1:
lock a
lock b
thread 2:
wait for a
lock c (when a locked)
thread 3:
wait for a
wait for b
wait for c如果一个线程（比如线程3）需要一些锁，那么它必须按照确定的顺序获取锁。它只有获得了从顺序上排在前面的锁之后，才能获取后面的锁。
例如，线程2和线程3只有在获取了锁a之后才能尝试获取锁c(译者注：获取锁a是获取锁c的必要条件)。因为线程1已经拥有了锁a，所以线程2和3需要一直等到锁a被释放。然后在它们尝试对b或c加锁之前，必须成功地对a加了锁。
按照顺序加锁是一种有效的死锁预防机制。但是，这种方式需要你事先知道所有可能会用到的锁(译者注：并对这些锁做适当的排序)，但总有些时候是无法预知的。
加锁时限
另外一个可以避免死锁的方法是在尝试获取锁的时候加一个超时时间，这也就意味着在尝试获取锁的过程中若超过了这个时限该线程则放弃对该锁请求。若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁，然后等待一段随机的时间再重试。这段随机的等待时间让其它线程有机会尝试获取相同的这些锁，并且让该应用在没有获得锁的时候可以继续运行(译者注：加锁超时后可以先继续运行干点其它事情，再回头来重复之前加锁的逻辑)。
以下是一个例子，展示了两个线程以不同的顺序尝试获取相同的两个锁，在发生超时后回退并重试的场景：
thread 1 locks a
thread 2 locks b
thread 1 attempts to lock b but is blocked
thread 2 attempts to lock a but is blocked
thread 1's lock attempt on b times out
thread 1 backs up and releases a as well
thread 1 waits randomly (e.g. 257 millis) before retrying.
thread 2's lock attempt on a times out
thread 2 backs up and releases b as well
thread 2 waits randomly (e.g. 43 millis) before retrying.在上面的例子中，线程2比线程1早200毫秒进行重试加锁，因此它可以先成功地获取到两个锁。这时，线程1尝试获取锁a并且处于等待状态。当线程2结束时，线程1也可以顺利的获得这两个锁（除非线程2或者其它线程在线程1成功获得两个锁之前又获得其中的一些锁）。
需要注意的是，由于存在锁的超时，所以我们不能认为这种场景就一定是出现了死锁。也可能是因为获得了锁的线程（导致其它线程超时）需要很长的时间去完成它的任务。
此外，如果有非常多的线程同一时间去竞争同一批资源，就算有超时和回退机制，还是可能会导致这些线程重复地尝试但却始终得不到锁。如果只有两个线程，并且重试的超时时间设定为0到500毫秒之间，这种现象可能不会发生，但是如果是10个或20个线程情况就不同了。因为这些线程等待相等的重试时间的概率就高的多（或者非常接近以至于会出现问题）。
(译者注：超时和重试机制是为了避免在同一时间出现的竞争，但是当线程很多时，其中两个或多个线程的超时时间一样或者接近的可能性就会很大，因此就算出现竞争而导致超时后，由于超时时间一样，它们又会同时开始重试，导致新一轮的竞争，带来了新的问题。)
这种机制存在一个问题，在java中不能对synchronized同步块设置超时时间。你需要创建一个自定义锁，或使用java5中java.util.concurrent包下的工具。写一个自定义锁类不复杂，但超出了本文的内容。后续的java并发系列会涵盖自定义锁的内容。
死锁检测
死锁检测是一个更好的死锁预防机制，它主要是针对那些不可能实现按序加锁并且锁超时也不可行的场景。
每当一个线程获得了锁，会在线程和锁相关的数据结构中（map、graph等等）将其记下。除此之外，每当有线程请求锁，也需要记录在这个数据结构中。
当一个线程请求锁失败时，这个线程可以遍历锁的关系图看看是否有死锁发生。例如，线程a请求锁7，但是锁7这个时候被线程b持有，这时线程a就可以检查一下线程b是否已经请求了线程a当前所持有的锁。如果线程b确实有这样的请求，那么就是发生了死锁（线程a拥有锁1，请求锁7；线程b拥有锁7，请求锁1）。
当然，死锁一般要比两个线程互相持有对方的锁这种情况要复杂的多。线程a等待线程b，线程b等待线程c，线程c等待线程d，线程d又在等待线程a。线程a为了检测死锁，它需要递进地检测所有被b请求的锁。从线程b所请求的锁开始，线程a找到了线程c，然后又找到了线程d，发现线程d请求的锁被线程a自己持有着。这是它就知道发生了死锁。
下面是一幅关于四个线程（a,b,c和d）之间锁占有和请求的关系图。像这样的数据结构就可以被用来检测死锁。
那么当检测出死锁时，这些线程该做些什么呢？
一个可行的做法是释放所有锁，回退，并且等待一段随机的时间后重试。这个和简单的加锁超时类似，不一样的是只有死锁已经发生了才回退，而不会是因为加锁的请求超时了。虽然有回退和等待，但是如果有大量的线程竞争同一批锁，它们还是会重复地死锁（编者注：原因同超时类似，不能从根本上减轻竞争）。
一个更好的方案是给这些线程设置优先级，让一个（或几个）线程回退，剩下的线程就像没发生死锁一样继续保持着它们需要的锁。如果赋予这些线程的优先级是固定不变的，同一批线程总是会拥有更高的优先级。为避免这个问题，可以在死锁发生的时候设置随机的优先级。
扩展阅读:译者注
所谓死锁都是因为”互掐”导致的，也许是暗中”互掐”,也许是太明显的”互掐”。
代码中体现为
线程a执行的代码：
sychronized(object1)
{
...业务操作
sychronized(object2)
{
...业务操作
}
}线程b执行的代码：
sychronized(object2)
{
...业务操作
sychronized(object1)
{
...业务操作
}
}上面这种情况是最基本，最简单的死锁规则，其它死锁场景都可以从中演变而来，例如：
- 多个线程乱序争用某些对象锁，当多个线程之间的锁争用依赖形成环形结构时，就可能会引起死锁（上述例子只是简单的2个线程对2个资源的交叉争用）
- 容易忽略对this加锁，也是对一个对象加锁，在这个过程中去调用其他拥有锁的方法，就可能导致不容易发现的死锁。实例代码如下：
class a
{
private b b = new b();
sychronized void fun()
{
b.fun();
}
sychronized void fun2()
{}
}
class b
{
private a a = new a();
sychronized void fun()
{
a.fun2();
}
}a的实例当中包含了b的实例，b也包含了a的实例，当a类中调用fun()方法时，会间接调用b类中的fun2()方法，这没有什么问题。但如果在这个过程中一个线程调用a中的fun()方法成功，获取到a的实例对象(this)的锁，存在另一个线程访问b的fun()方法，也同样获取到b的实例对象(this)的锁，就出现”互掐”现象了。
-
父类方法调用子类方法，子类直接或间接地再调用父类的方法，在这个过程中可能会发生某个方法级别的加锁，也就是更加隐藏地锁住this，某些方法中还可能对外部某个对象进行锁操作，同样可能产生”互掐”。
-
更加隐蔽地例子：
void fun(object from,object to)
{
sychronized(from)
{
sychronized(to)
{
...业务代码
}
}
}假如有两个线程都持有了a、b两个对象，其中一个线程传入地参数是a、b，另一个线程传入的是b、a，此时就动态地出现了”互掐”情况，这种死锁我们把它叫作”动态死锁”。
- 饥饿死锁，fork/join使用fixed方式线程池。