在JAVA编程中，有3种典型的死锁类型：
- 静态的锁顺序死锁
- 动态的锁顺序死锁
- 协作对象之间发生的死锁
静态的锁顺序死锁
a和b两个方法都需要获得A锁和B锁。一个线程执行a方法且已经获得了A锁，在等待B锁；另一个线程执行了b方法且已经获得了B锁，在等待A锁。这种状态，就是发生了静态的锁顺序死锁。
//可能发生静态锁顺序死锁的代码
static class StaticLockOrderDeadLock{
private final Object lockA=new Object();
private final Object lockB=new Object();
public void a(){
synchronized (lockA) {
//...
//线程1 运行到这里，持有lockA，等待lockB
synchronized (lockB) {
System.out.println("function a");
}
}
}
public void b(){
synchronized (lockB) {
//...
//线程2 运行到这里，持有lockB，等待lockA
synchronized (lockA) {
System.out.println("function b");
}
}
}
}
- 解决静态的锁顺序死锁的方法就是：所有需要多个锁的线程，都要以相同的顺序来获得锁。
//正确的代码
static class StaticLockOrderDeadLock2{
private final Object lockA=new Object();
private final Object lockB=new Object();
public void a(){
synchronized (lockA) {
synchronized (lockB) {
System.out.println("function a");
}
}
}
public void b(){
synchronized (lockA) {
synchronized (lockB) {
System.out.println("function b");
}
}
}
}
- 动态的锁顺序死锁解决方案如下：使用System.identifyHashCode()返回hashcode的大小来保证锁的顺序。确保所有的线程都以相同的顺序获得锁
//正确的代码
static class DynamicLockOrderDeadLock2{
private final Object myLock=new Object();
public void method(Object lockA, Object lockB){
int fromLockA = System.identityHashCode(lockA);
int fromLockB = System.identityHashCode(lockB);
if(fromLockA < fromLockB){
getResource(lockA, lockB);
}else if(fromLockA > fromLockB){
getResource(lockB, lockA);
}else {
synchronized (myLock) {
getResource(lockA, lockB);
}
}
}
private void getResource(Object lockA, Object lockB) {
synchronized (lockA) {
synchronized (lockB){
System.out.println("DynamicLockOrderDeadLock -- " + index);
index++;
}
}
}
}
协作对象之间发生的死锁：
有时，死锁并不会那么明显，比如两个相互协作的类之间的死锁，比如下面的代码：一个线程调用了ModelA对象的setA方法，另一个线程调用了ModelB对象的method方法。此时可能会发生，第一个线程持有ModelA对象锁并等待ModelB对象锁，另一个线程持有ModelB对象锁并等待ModelA对象锁。
//可能发生死锁
static class ModelA{
private int a;
private ModelB modelB;
public ModelA(ModelB modelB) {
this.modelB = modelB;
}
public synchronized void setA(int a) {
this.a = a;
modelB.addModelA(this);
}
public synchronized int getA() {
return a;
}
@Override
public String toString() {
return "ModelA{" +
"a=" + a +
'}';
}
}
static class ModelB{
private final List<ModelA> modelAS = new ArrayList<>();
public synchronized void addModelA(ModelA modelA){
modelAS.add(modelA);
}
public synchronized void method(){
for (ModelA modelA:modelAS) {
System.out.println(" a: " + modelA.getA());
}
}
}
上面的代码中，我们在持有锁的情况下调用了外部的方法，这是非常危险的（可能发生死锁）。为了避免这种危险的情况发生，我们使用开放调用。如果调用某个外部方法时不需要持有锁，我们称之为开放调用。
总结
综上，是常见的3种死锁的类型。即：静态的锁顺序死锁，动态的锁顺序死锁，协作对象之间的死锁。在写代码时，要确保线程在获取多个锁时采用一致的顺序。同时，要避免在持有锁的情况下调用外部方法。
