Web全栈~35.使用tryLock()避免死锁
Web全栈~35.显式锁
上一期
接口Lock
显式锁接口的定义
lock（）/unlock（）：就是普通的获取锁和释放锁方法，lock（）会阻塞直到成功。
lockInterruptibly（）：与lock（）的不同是，它可以响应中断，如果被其他线程中断了，则抛出InterruptedException。
tryLock（）：只是尝试获取锁，立即返回，不阻塞，如果获取成功，返回true，否则返回false。
tryLock（long time，TimeUnit unit）：先尝试获取锁，如果能成功则立即返回true，否则阻塞等待，但等待的最长时间由指定的参数设置，在等待的同时响应中断，如果发生了中断，抛出InterruptedException，如果在等待的时间内获得了锁，返回true，否则返回false。
newCondition：新建一个条件，一个Lock可以关联多个条件
可以看出，相比synchronized，显式锁支持以非阻塞方式获取锁、可以响应中断、可以限时，这使得它灵活得多。
ReentrantLock
Lock接口的主要实现类是ReentrantLock，它的基本用法lock/unlock实现了与synchronized一样的语义
ReentrantLock有两个构造方法
参数fair表示是否保证公平，不指定的情况下，默认为false，表示不保证公平。所谓公平是指，等待时间最长的线程优先获得锁。保证公平会影响性能，一般也不需要，所以默认不保证，synchronized锁也是不保证公平的
使用显式锁，一定要记得调用unlock。一般而言，应该将lock之后的代码包装到try语句内，在finally语句内释放锁。
代码示例
public void fun() {
lock.lock();
try{
count++;
}finally {
lock.unlock();
}
}
使用tryLock()避免死锁
使用tryLock（），可以避免死锁。在持有一个锁获取另一个锁而获取不到的时候，可以释放已持有的锁，给其他线程获取锁的机会，然后重试获取所有锁。
银行转账实例
账户类
class Account{
private Lock lock = new ReentrantLock();
private volatile double money;
public Account(double initialMoney){
this.money = initialMoney;
}
public void add(double money){
lock.lock();
try{
this.money = money;
}finally {
lock.unlock();
}
}
public void reduce(double money){
lock.lock();
try{
this.money -= money;
}finally {
lock.unlock();
}
}
public double getMoney() {
return money;
}
public void lock(){
lock.lock();
}
public void unlock(){
lock.unlock();
}
public boolean tryLock(){
return lock.tryLock();
}
}
在账户之间转账，需要两个账户都锁定，如果不使用tryLock，而直接使用lock就会发生死锁。这里可以试一试
class NoEnoughMoney extends Exception {
public static void transfer(Account from,Account to,double money)
throws NoEnoughMoney {
from.lock();
try {
to.lock();
try {
if(from.getMoney() >= money) {
from.reduce(money);
to.add(money);
} else {
throw new NoEnoughMoney();
}
} finally {
to.unlock();
}
} finally {
from.unlock();
}
}
}
模拟死锁的过程
public static void simulateDeadLock() {
final int accountNum = 10;
final Account[]accounts = new Account[accountNum];
final Random rnd = new Random();
for(int i = 0; i < accountNum; i++) {
accounts[i]= new Account(rnd.nextInt(10000));
}
int threadNum = 100;
Thread[]threads = new Thread[threadNum];
for(int i = 0; i < threadNum; i++) {
threads[i]= new Thread() {
public void run() {
int loopNum = 100;
for(int k = 0; k < loopNum; k++) {
int i = rnd.nextInt(accountNum);
int j = rnd.nextInt(accountNum);
int money = rnd.nextInt(10);
if(i!= j) {
try {
transfer(accounts[i],accounts[j],money);
} catch (NoEnoughMoney e) {
}
}
}
}
};
threads[i].start();
}
}
这里有10个账户，100个线程，每个线程执行100次循环，在每次循环中，随机挑选两个账户进行转账。每次执行该段代码都会发生死锁。
使用tryLock实现转账
public static boolean tryTransfer(Account from,Account to,double money) throws NoEnoughMoney {
if(from.tryLock()) {
try {
if(to.tryLock()) {
try {
if(from.getMoney() >= money) {
from.reduce(money);
to.add(money);
} else {
throw new NoEnoughMoney();
}
return true;
} finally {
to.unlock();
}
}
} finally {
from.unlock();
}
}
return false;
}
如果两个锁都能够获得，且转账成功，则返回true，否则返回false。不管怎样，结束都会释放所有锁。
transfer方法可以循环调用该方法以避免死锁
public static void transfer(Account from,Account to,double money) throws NoEnoughMoney {
boolean success = false;
do {
success = tryTransfer(from,to,money);
if(!success) {
Thread.yield();
}
} while (!success);
}