在上一篇互斥锁的时候最后使用Account.class作为互斥锁，来解决转载问题，所有的账户转账操作都是串行的，性能太差。

我们可以考虑缩小锁定的范围，使用细粒度的锁，来提高并行度。例如用两把锁，转出账本一把，转入账本一把，在transfer()方法内部，我们首先尝试锁定转出账户this，然后尝试锁定转入账户target，只有当两者都成功时，才执行转账操作。

这样改造使用细粒度的锁，可以提高并行度，但是是有代价的，这个代价就是可能会死锁。

导致死锁的特殊场景就是，例如同一时间，账户A给账户B转账，账户B也在给账户A转账，都第一时间获取到了锁定转出账本的锁，在获取转入账本的锁时发现锁以及被抢占，就出现死锁。

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

用图来解释就是：

如何预防死锁

并发程序一旦死锁，一般没有没有特别好的方法，很多时候只能重启应用。解决死锁问题最好的方法是规避死锁。

出现死锁的四个条件：

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

只要我们破坏其中一个，就可以成功避免死锁。

互斥这个条件是不能破坏的，加锁就是为了互斥，其他三个条件是有办法破坏的：

• 对于“占用且等待”这个条件，我们可以一次性申请所有资源，这样就不存在等待了
• 对于“不可抢占”这个条件，占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放占有的资源，这样不可抢占的这个条件就破坏掉了。
• 对于“循环等待”这个条件，可以靠按顺序申请资源来预防，所谓按序申请，是指资源是有线性顺序的，申请的时候可以先申请资源序号小的，再申请资源序号大的，这样线性化后自然就不存在循环了。

####### 1.破坏占用且等待条件

理论上破坏这个条件，可以一次性申请所有资源。

对应到银行转账可以增加一个账本管理员，然后只允许账本管理员从文件架上拿账本，所有的转账都要先从账本管理员那拿到账本。例如账户A给账户B转账，账本管理员如果发现只有账本A在，就不会给柜员，来操作转账，只有账本A和账本B都在，才会给柜员进行转账操作，这样就保证了“一次性申请所有资源”。

对应的代码实现就是，“同时申请”这个操作是一个临界区，我们也需要一个角色来管理这个临界区，我们定义一个类Allocator，它有两个重要的功能，分别是同时申请资源apply()和同时释放资源free()。账户Account在执行转账操作的时候，首先向Allocator同时申请转出账户和转入账户这两个资源，成功后再锁定这两个资源，当转账操作执行完后释放锁。

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了，因为synchronized再申请资源的时候，如果申请不到资源就会进入阻塞状态，就不能释放资源了。可以使用java.util.concurrent这个包下提供的Lock就可以解决了。

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;
        }
      }
    }
  } 
}

学习来源：极客时间 《Java 并发编程实战》学习笔记 Day03