【多线程：活跃性】死锁、活锁、饥饿
01.介绍
死锁：两个线程 t1 t2，两把锁 A B，t1持有A锁 t2持有B锁，此时t1想要再获得B锁 t2想要再获得A锁，但是它们都不释放自己所持有的锁，最终导致死锁。
活锁：两个线程互相改变对方的结束条件，导致最后谁也没办法结束
饥饿：多个线程中 有一个线程t，由于线程之间的冲突 导致t线程分的时间片低，导致t线程基本不运行，这种情况下t线程就处于饥饿
02.死锁
案例
两个线程 t1 t2，两把锁 A B，t1持有A锁 t2持有B锁，此时t1想要再获得B锁 t2想要再获得A锁
package cn.itcast.n4.deadlock;
import lombok.extern.slf4j.Slf4j;
import static cn.itcast.n2.util.Sleeper.sleep;
@Slf4j(topic = "c.TestDeadLock")
public class TestDeadLock {
public static void main(String[] args) {
test1();
}
private static void test1() {
Object A = new Object();
Object B = new Object();
Thread t1 = new Thread(() -> {
synchronized (A) {
log.debug("lock A");
sleep(1);
synchronized (B) {
log.debug("lock B");
log.debug("操作...");
}
}
}, "t1");
Thread t2 = new Thread(() -> {
synchronized (B) {
log.debug("lock B");
sleep(0.5);
synchronized (A) {
log.debug("lock A");
log.debug("操作...");
}
}
}, "t2");
t1.start();
t2.start();
}
}
结果
01:08:32.822 c.TestDeadLock [t1] - lock A
01:08:32.822 c.TestDeadLock [t2] - lock B
解释
可以看出t1 t2线程都尝试获取对方的锁，但最终陷入死锁，代码没有往下执行
定位死锁
前提：运行上述案例的代码，用下面的方法查看是否死锁 以及 死锁信息
方法一：命令行jstack
首先我们用jps命令找到 我们需要的java程序 也就是 TestDeadLock
然后我们用jstack命令 查看19008进程的线程详细信息
我们在里面发现了记录死锁的信息，可以看出是 t1 t2线程死锁
再后面列出死锁的详细信息，包括死锁的位置
方法二
通过图像界面工具jconsole来查看
首先我们win+R搜索jconsole
然后进入图形界面选择TestDeadLock 然后连接
然后我们点击左上方线程，查看线程的详细信息，再点击左下角的检查死锁
我们看出死锁线程为 t1 t2，点击t1 t2线程可以查看详细信息
03.死锁-哲学家就餐问题
介绍
哲学家就餐问题是操作系统中介绍死锁时的经典案例。
这个故事说的是，有五位哲学家 坐在圆桌旁，他们只做两件事，吃饭和思考，思考一会吃口饭 吃完饭继续思考。吃饭时需要两根筷子，桌子上共有5根筷子，每位哲学家左右手各有一根筷子，如果身边的筷子被拿完，自己就得等待。
条件补充
我们规定 每个人都先拿自己左手边的筷子 再拿右手边的筷子。
问题矛盾点
我们发现 如果按上述描述规则吃饭，势必会有一种情况 就是 每个人都拿到自己左手边的筷子 但还需要右手边的筷子，但是右手边的筷子已经被占用，导致死锁。
代码
public class TestDeadLock {
public static void main(String[] args) {
Chopstick c1 = new Chopstick("1");
Chopstick c2 = new Chopstick("2");
Chopstick c3 = new Chopstick("3");
Chopstick c4 = new Chopstick("4");
Chopstick c5 = new Chopstick("5");
new Philosopher("苏格拉底", c1, c2).start();
new Philosopher("柏拉图", c2, c3).start();
new Philosopher("亚里士多德", c3, c4).start();
new Philosopher("赫拉克利特", c4, c5).start();
new Philosopher("阿基米德", c5, c1).start();
}
}
@Slf4j(topic = "c.Philosopher")
class Philosopher extends Thread {
Chopstick left;
Chopstick right;
public Philosopher(String name, Chopstick left, Chopstick right) {
super(name);
this.left = left;
this.right = right;
}
@Override
public void run() {
while (true) {
// 尝试获得左手筷子
synchronized (left) {
// 尝试获得右手筷子
synchronized (right) {
eat();
}
}
}
}
Random random = new Random();
private void eat() {
log.debug("eating...");
Sleeper.sleep(0.5);
}
}
class Chopstick {
String name;
public Chopstick(String name) {
this.name = name;
}
@Override
public String toString() {
return "筷子{" + name + '}';
}
}结果
01:48:37.984 c.Philosopher [苏格拉底] - eating...
01:48:37.984 c.Philosopher [亚里士多德] - eating...
01:48:38.493 c.Philosopher [阿基米德] - eating...
01:48:38.493 c.Philosopher [柏拉图] - eating...
01:48:39.003 c.Philosopher [柏拉图] - eating...
01:48:39.003 c.Philosopher [赫拉克利特] - eating...
01:48:39.513 c.Philosopher [苏格拉底] - eating...
01:48:39.513 c.Philosopher [赫拉克利特] - eating...
解释
我们创建一个筷子类Chopstick，一个哲学家类Philosopher，创建了五个筷子类对象 五个哲学家类对象，哲学家每次先尝试获取左边的筷子 再尝试获取右边的筷子，可以看到结果 产生了死锁。
根据jstack的结果 我们可以看出，确实发生了死锁，原因是五个哲学家都需要自己右手边哲学家的筷子
04.活锁
介绍
两个线程互相改变对方的结束条件，导致最后谁也没办法结束
例子
两个线程t1 t2 一个成员变量count=10，t1线程的结束条件是count<=0，t2线程的结束条件是count>=20，但是t1线程是在不断减少count，t2线程是在不断增加count，最终导致两个线程动达不到结束条件 导致活锁
代码
@Slf4j(topic = "c.TestLiveLock")
public class TestLiveLock {
static volatile int count = 10;
static final Object lock = new Object();
public static void main(String[] args) {
new Thread(() -> {
// 期望减到 0 退出循环
while (count > 0) {
sleep(0.2);
count--;
log.debug("count: {}", count);
}
}, "t1").start();
new Thread(() -> {
// 期望超过 20 退出循环
while (count < 20) {
sleep(0.2);
count++;
log.debug("count: {}", count);
}
}, "t2").start();
}
}
结果
一直运行，数值保持在0~20期间
解决方法
把两个线程指令执行的时间进行交错就行了，具体就是暂停时间改为随机
05.饥饿
介绍
多个线程中 有一个线程t，由于线程之间的冲突 导致t线程分的时间片低，导致t线程基本不运行，这种情况下t线程就处于饥饿
案例
我们前面遇见了死锁-哲学家问题，这个问题可以通过 顺序加锁的方法解决，但是这个方法会导致饥饿
代码
public class TestDeadLock {
public static void main(String[] args) {
Chopstick c1 = new Chopstick("1");
Chopstick c2 = new Chopstick("2");
Chopstick c3 = new Chopstick("3");
Chopstick c4 = new Chopstick("4");
Chopstick c5 = new Chopstick("5");
new Philosopher("苏格拉底", c1, c2).start();
new Philosopher("柏拉图", c2, c3).start();
new Philosopher("亚里士多德", c3, c4).start();
new Philosopher("赫拉克利特", c4, c5).start();
new Philosopher("阿基米德", c1, c5).start();
}
}
@Slf4j(topic = "c.Philosopher")
class Philosopher extends Thread {
Chopstick left;
Chopstick right;
public Philosopher(String name, Chopstick left, Chopstick right) {
super(name);
this.left = left;
this.right = right;
}
@Override
public void run() {
while (true) {
// 尝试获得左手筷子
synchronized (left) {
// 尝试获得右手筷子
synchronized (right) {
eat();
}
}
}
}
Random random = new Random();
private void eat() {
log.debug("eating...");
Sleeper.sleep(0.5);
}
}
class Chopstick {
String name;
public Chopstick(String name) {
this.name = name;
}
@Override
public String toString() {
return "筷子{" + name + '}';
}
}结果
02:32:24.639 c.Philosopher [阿基米德] - eating...
02:32:24.639 c.Philosopher [亚里士多德] - eating...
02:32:25.149 c.Philosopher [赫拉克利特] - eating...
02:32:25.658 c.Philosopher [赫拉克利特] - eating...
02:32:26.168 c.Philosopher [亚里士多德] - eating...
02:32:26.168 c.Philosopher [阿基米德] - eating...
02:32:26.678 c.Philosopher [亚里士多德] - eating...
02:32:26.678 c.Philosopher [阿基米德] - eating...
02:32:27.188 c.Philosopher [赫拉克利特] - eating...
02:32:27.697 c.Philosopher [阿基米德] - eating...
02:32:27.697 c.Philosopher [亚里士多德] - eating...
02:32:28.207 c.Philosopher [赫拉克利特] - eating...
02:32:28.717 c.Philosopher [赫拉克利特] - eating...
02:32:29.226 c.Philosopher [赫拉克利特] - eating...
02:32:29.736 c.Philosopher [阿基米德] - eating...
02:32:29.736 c.Philosopher [亚里士多德] - eating...
02:32:30.246 c.Philosopher [阿基米德] - eating...
02:32:30.246 c.Philosopher [亚里士多德] - eating...
02:32:30.756 c.Philosopher [赫拉克利特] - eating...
02:32:31.265 c.Philosopher [赫拉克利特] - eating...
02:32:31.775 c.Philosopher [亚里士多德] - eating...
02:32:31.775 c.Philosopher [阿基米德] - eating...
02:32:32.285 c.Philosopher [亚里士多德] - eating...
02:32:32.795 c.Philosopher [亚里士多德] - eating...
02:32:33.304 c.Philosopher [赫拉克利特] - eating...
02:32:33.814 c.Philosopher [亚里士多德] - eating...
02:32:34.324 c.Philosopher [赫拉克利特] - eating...
02:32:34.833 c.Philosopher [赫拉克利特] - eating...
02:32:35.343 c.Philosopher [赫拉克利特] - eating...
02:32:35.853 c.Philosopher [赫拉克利特] - eating...
02:32:36.363 c.Philosopher [赫拉克利特] - eating...
02:32:36.872 c.Philosopher [赫拉克利特] - eating...
解释
观察下面两个图
我们通过顺序加锁 解决了死锁问题，但也同时使得 阿基米德竞争加大获得两个筷子的概率大大下降 使得赫拉克利特竞争减小获得两个筷子的概率大大增强，也就是最终结果显示的那样。
阿基米德现在的这种情况就被成为饥饿。
如何解决饥饿
后续文章会讲解ReentrantLock 它可以解决。
