只有拿到转出账户和转入账户的资源，才能转账成功。

首先尝试锁定转出账户this，然后尝试锁定转入账户target，只有两者都成功时，才可以执行转账操作。

class Account {
  private int balance;
  // 转账
  void transfer(Account target, int amt){
    // 锁定转出账户
    synchronized(this) {          ①
      // 锁定转入账户
      synchronized(target) {      ②          
        if (this.balance > amt) {
          this.balance -= amt;
          target.balance += amt;
        }
      }
    }
  } 
}

细粒度锁：可以提高并行度，性能优化的一个重要手段，但是可能会导致死锁。

死锁：一组互相竞争资源的线程因互相等待，导致永久阻塞的现象。

上述代码发生死锁的原因：

线程T1执行账户A转账户B的操作；

线程T2执行账户B转账户A的操作；

当T1和T2同时执行完①处的代码时，T1获得了账户A的锁，T2获得了账户B的锁，之后T1和T2在执行②处的代码时，T1试图获取账户B的锁，发现账户B已经被锁定了，所以T1开始等待，T2试图获取账户A的锁，发现账户A已经被锁定了，所以T2开始等待。T1、T2会无期限的等待下去，就产生了死锁。

 

如何预防死锁？

死锁发生的条件：

• 互斥，共享资源X和Y只能被一个线程占用；
• 占有且等待，线程T1已经取得共享资源X，在等待共享资源Y的时候，不释放共享资源X；
• 不可抢占，其他线程不能强行抢占线程T1占用的资源；
• 循环等待，线程T1等待线程T2占用的资源，线程T2等待线程T1占用的资源。

当上述四个条件都发生时，才会产生死锁。只要破解其中的一个，就可以避免死锁的发生。

“互斥”，没有办法破坏，因为锁的行为就是互斥。

• “占有且等待”，可以一次性申请所有的资源，这样就不存在等待了；
• “不可抢占”，占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
• “循环等待”，按序申请，申请的时候先申请资源号小的，再申请资源号大的，这样线性化后就不存在循环了。

 

1.破坏占用且等待条件

设置一个角色，同时申请资源和同时释放资源，账户类里面持有一个角色单例（必须是单例，只能有一个人来分配资源）

class Allocator {
  private List<Object> als =
    new ArrayList<>();
  // 一次性申请所有资源
  synchronized boolean apply(
    Object from, Object to){
    if(als.contains(from) ||
         als.contains(to)){
      return false;  
    } else {
      als.add(from);
      als.add(to);  
    }
    return true;
  }
  // 归还资源
  synchronized void free(
    Object from, Object to){
    als.remove(from);
    als.remove(to);
  }
}

class Account {
  // actr应该为单例
  private Allocator actr;
  private int balance;
  // 转账
  void transfer(Account target, int amt){
    // 一次性申请转出账户和转入账户，直到成功
    while(!actr.apply(this, target))
      ；
    try{
      // 锁定转出账户
      synchronized(this){              
        // 锁定转入账户
        synchronized(target){           
          if (this.balance > amt){
            this.balance -= amt;
            target.balance += amt;
          }
        }
      }
    } finally {
      actr.free(this, target)
    }
  } 
}

2.破坏不可抢占条件

核心是能够主动释放它所占用的资源，synchronized申请资源的时候，如果申请不到，线程直接进入阻塞状态了，释放不了已经占用的资源。

3.破坏循环等待条件

需要对资源进行排序，按序申请资源

class Account {
  private int id;
  private int balance;
  // 转账
  void transfer(Account target, int amt){
    Account left = this        ①
    Account right = target;    ②
    if (this.id > target.id) { ③
      left = target;           ④
      right = this;            ⑤
    }                          ⑥
    // 锁定序号小的账户
    synchronized(left){
      // 锁定序号大的账户
      synchronized(right){ 
        if (this.balance > amt){
          this.balance -= amt;
          target.balance += amt;
        }
      }
    }
  } 
}