死锁
- 前言
- 可重入锁
- 逻辑
- 两个线程两把锁（死锁）
- 死锁的特点
- 多个线程多把锁（哲学家就餐问题）
- 总结
前言
在前面的文章中，介绍了锁的基本使用方式——锁
在上一篇文章中，通过synchronized关键字进行加锁操作，使得【多线程修改同一变量】的情况可以得到解决。
那么在本文中，将会继续讲解锁的相关知识点。
可重入锁
我们可以通过synchronized确定锁对象，对线程进行加锁的操作。那么如果锁对象重复使用是否会出现不一样的结果？
在下面的案例中，t1和t2线程使用了连续synchronized，设置的加锁对象同样是counter，如果运行这段代码，结果却是正确的。
理论上，当synchronized(counter)开始使用时，只有执行完其中的代码（大括号中的代码块）才会释放锁。而这个锁中又嵌套了相同的锁，按道理来说此时counter锁对象还没有被释放，应该出现阻塞等待状态最终代码无法运行才是。
那么为什么在Java中这段代码可以编译通过？
原因： 在Java中，已经对synchronized内部进行了特殊处理。在每个锁对象中，会记录当前是哪个线程持有这把锁，接下来，当针对这个对象进行加锁操作的时候就会进行判定，判定当前尝试加锁线程是否是这一对象锁的线程。 通过这样的操作，系统就可以知道如果不是，就会阻塞；如果是，就会直接放行。
class Counter {
public static int count;
void add(){
count++;
}
public int getCount(){
return count;
}
}
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(()-> {
for (int i = 0; i < 50000; i++) {
synchronized (counter) {
synchronized (counter) {
counter.add();
}
}
}
});
Thread t2 = new Thread(()-> {
for (int i = 0; i < 50000; i++) {
synchronized (counter) {
synchronized (counter) {
counter.add();
}
}
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("count = "+counter.getCount());
}
逻辑
当加了多层锁的时候，代码如何知道执行到哪里要真正进行解锁。如果有若干层加锁操作，如何判定当前遇到的}是最外层的} ？
以我的理解，进行加锁操作时在内部给锁对象设计了一个计数器(int n)。 每次遇到【{ 】时，n++，遇到【 } 】时，n–，当n=0时才真正解锁。
通过这样的方式，针对同一线程中的同一锁对象进行的锁操作，可以让程序猿避免了死锁的情况，我们也称之为可重入锁。
两个线程两把锁（死锁）
现在存在线程t1和线程t2；锁对象A和B。
当进行锁操作的时候，可能会出现这样的情况：线程1和线程2都需要使用到锁A和锁B，对于线程A来说，首先获取锁A然后获取锁B；而对于B来说，首先获取锁B再获取锁A。
让两个线程同时获得第一把锁，接下来需要尝试去获取对方的锁。
在下面的代码启动后，线程t1获取到了锁locker1，线程t2获取到了锁locker2.
对于t1，接下来需要获取locker2才能继续执行接下来的代码
对于t2,需要获取locker1才能继续执行接下来的代码
两个线程之间无法让步，于是一同进入了阻塞等待状态，都在等待对方释放锁。
public static void main(String[] args) {
Object locker1 = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(()-> {
synchronized (locker1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker2){
System.out.println("获取到了2把锁");
}
}
});
Thread t2 = new Thread(()-> {
synchronized (locker2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker1){
System.out.println("获取到了2把锁");
}
}
});
t1.start();
t2.start();
}
在执行这段代码后，我们可以通过jconsole查看线程状态。如下图所示，我们可以知道两个线程都处于阻塞状态，同时我们也可以知道阻塞所需要获取的锁目前在哪个线程身上。
死锁的特点
1.锁具有互斥性。这是锁的基本特点，当一个线程拿到锁A时，其他线程只能等待该线程释放。
2.锁不可抢占。只有该线程主动释放锁，别的线程无法抢占。
3.请求和保持。线程拿到锁以后可以继续尝试获取其他锁。
4.循环等待。多个线程多个锁的状态中，出现了A等待B，B等待A的情况。
当全部满足这些条件以后，就可以发生死锁。
多个线程多把锁（哲学家就餐问题）
情景：在一个餐桌上存在五个哲学家，他们做两件事情：一是思考哲学，二是就餐。
每个哲学家左右手各有一根筷子以供就餐时使用。如果哲学家手中只有一根筷子，他会等到另一根筷子拥有的时候才会就餐，而不会放下筷子。
通过这个情景，我们可以很明显的预知到一种情况：所有的哲学家手中都拿起左边的筷子，于是所有哲学家都停下了，进入阻塞等待状态。
我们通过这个问题可以反映到线程的情况，因为多线程多锁的原因，如果没有合理安排则会导致线程阻塞甚至死锁！
解决这种情况的一种办法就是约定好加锁的顺序，破除循环等待的情况。
在下面的代码中，两个线程轮流获取locker1和locker2，这就可以有效规避死锁的问题了。
public static void main(String[] args) {
Object locker1 = new Object();
Object locker2 = new Object();
Thread t1 = new Thread(()-> {
synchronized (locker1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker2){
System.out.println("获取到了2把锁");
}
}
});
Thread t2 = new Thread(()-> {
synchronized (locker1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (locker2){
System.out.println("获取到了2把锁");
}
}
});
t1.start();
t2.start();
}
总结
死锁在多线程中是及其常见的一个问题，导致了线程的不安全。是我们要极力规避的情况。我们了解了死锁发生的情况，死锁的原因等多个点。
本文使用源码☞ 源码
