目录
1)死锁的四个必备条件:
- 互斥,共享资源 X 和 Y 只能被一个线程占用;
- 占有且等待,线程 T1 已经取得共享资源 X,在等待共享资源 Y 的时候,不释放共享资源 X;
- 不可抢占,其它线程不能强行抢占线程 T1 占有的资源;
- 循环等待,线程 T1 等待线程 T2 占有的资源,线程 T2 等待线程 T1 占有的资源。
我们只要破坏其中一个,就可以成功避免死锁的发生。
- 破坏互斥:互斥这个条件我们没有办法破坏,因为我们用锁就是为了互斥;
- 破坏占有且等待:我们可以一次性申请所有的资源,这样就不存在等待了;
- 破坏不可抢占:占有部分这样的线程进一步申请其他资源时,如果申请不到,可以主动释放占有的资源;
- 破坏循环等待:可以靠按序申请资源来预防。所谓按序申请,是指资源是有线性顺序的,申请的时候可以先申请资源序号小的,在申请资源序号大的,资源线性化后自然就不存在循环了。
我们已经从理论上解决了如何预防死锁,那具体如何体现在代码上,下面我们就来尝试用代码实践以下这些理论。
2)解决思索的3中方式
1.破坏占有且等待条件
从理论上讲,要破坏这个条件,可以一次性申请所有资源。在现实世界里,对于转账操作来说,它需要的资源有两个,一个是转出账户,一个是转入账户,怎样同时申请这两个账户呢?方法是,可以增加一个账本管理员,然后只允许账本管理员从文件架上拿账本,例如张三同时申请账本A 和 B,只有当账本 A 和 B 都在的时候才会给张三,只有就保证了一次性申请所有只有。
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);
}
}
}
上述方案优化思路:
其中while (!actr.apply(this, target));如果 apply() 操作耗时非常短,并且并发冲突量也不大时,这个方案还可以接受,但是如果该方法操作耗时非常长,或者并发冲突量大的时候,循环等待这种方案就不适用了,因为在这种场景下,可能要循环上万次才能获取到锁,太消耗CPU 了。
其实在这种场景下,最好的方案应该是:如果线程要求的条件不满足,则线程阻塞自己,进入等待状态;当线程要求的条件满足后,通知等待的线程重新执行。其中,使用线程阻塞的方式就能避免循环等待消耗CPU 的问题。
用 synchronized 实现等待 - 通知机制
在 Java 语言里,等待 -通知机制可以有多种实现方式,比如 Java 内置的 synchronized 配合 wait()、notify()、notifyAll()这三个方法就能轻松实现。
用 synchronized 实现互斥锁,我们应该很熟悉了,在下面这个图里,左边有一个等待队列,同一时刻,只允许一个线程进入 synchronized 保护的临界区(这个临界区可以看作大夫的诊室),当有一个线程进入临界区后,其他线程就只能进入图中左边的等待队列(相当于分诊等待)。这个等待队列和互斥锁是一对一的关系,每个互斥锁都有自己独立的等待队列。
在并发程序中,当一个线程进入临界区后,由于某些条件不满足时,需要进入等待状态,Java 对象的 wait() 方法就能满足这个需求。如上图,当调用 wait() 方法后,线程就会被阻塞,并且进入左边的等待队列中,这个等待队列也是互斥锁的等待队列。线程在进入等待队列的同时,会释放持有的互斥锁,线程释放锁后,其他线程就有机会获得锁,并进入临界区了。
那线程要求的条件满足时,该怎么通知这个等待的线程呢?很简单,就是 Java 对象的 notify() 和 notifyAll() 方法。我在下面这个图里为你大致描述了这个过程,当条件满足时调用 notify(),会通知等待队列(互斥锁的等待队列)中的线程,告诉它条件曾经满足过。
此外,还有一个需要注意的点,被通知的线程要想重新执行,仍然需要获取到互斥锁(因为曾经获取的锁在调用 wait() 时已经释放了)。
上面我们一直强调 wait()、notify()、notifyAll() 方法操作的等待队列是互斥锁的等待队列,所以如果 synchronized 锁定的是 this,那么对应的一定是 this.wait()、this.notify()、this.notifyAll();如果 synchronized 锁定的是 target,那么对应的一定是 target.wait()、target.notify()、target.notifyAll() 。而且 wait()、notify()、notifyAll() 这三个方法能够被调用的前提是已经获取了相应的互斥锁,所以我们会发现 wait()、notify()、notifyAll() 都是在 synchronized{}内部被调用的。如果在 synchronized{}外部调用,或者锁定的 this,而用 target.wait() 调用的话,JVM 会抛出一个运行时异常:java.lang.IllegalMonitorStateException。
wait() 方法和sleep() 方法都能让当前线程挂起一段时间,那么它们的区别是什么?
相同点:都会让渡CPU执行时间,等待再次调度。
不同点:
- wait 会释放持有的锁,而sleep不会;
- wait 只能在同步方法和同步块中使用,而sleep 任何地方都可以使用;
- wait 需要被唤醒,而sleep 不用;
- wait 是 Object 的方法,而 sleep 是 Thread 的方法;
- wait 无需捕获异常,而 sleep 需要捕获。
2.破坏不可抢占条件
破坏不可抢占资源条件看上去很简单,核心是要能够主动释放它占有的资源,这一点 synchronized 做不到,原因是 synchronized 申请资源时,如果申请不到,线程直接进入阻塞状态,而线程进入阻塞状态了,啥也干不了,也释放不了线程占有的资源。
不过 synchronized 解决不了,在Java SDK 中 java.util.concurrent 这个包下提供的 Lock 是可以轻松解决这个问题的。
3.破坏循环等待条件
破坏循环等待这个条件,需要对资源进行排序,然后按序申请资源。这个实现非常简单,我们假设每个账户都有不同的属性ID,按个ID 可以作为排序字断,申请的时候,我们可以按照从小到大的顺序来申请。
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;
}
}
}
}
}