8.谈谈线程安全：活跃性问题（死锁、活锁、饥饿）

最新推荐文章于 2023-03-22 10:46:23 发布

飞四海

最新推荐文章于 2023-03-22 10:46:23 发布

阅读量530

点赞数

分类专栏：多线程文章标签： java 开发语言

本文链接：https://blog.csdn.net/daohangtaiqian/article/details/128019890

版权

多线程专栏收录该内容

20 篇文章 4 订阅

订阅专栏

1.线程安全是什么？

现在我们做开发，到哪都会被问到线程安全的问题，那今天就好好总结下线程安全。

引用：

《Java Concurrency In Practice》的作者 Brian Goetz 对线程安全是这样理解的，当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行问题，也不需要进行额外的同步，而调用这个对象的行为都可以获得正确的结果，那这个对象便是线程安全的。

那意思就是如果某个对象是线程安全的，那么对于使用者而言，在使用时就不需要考虑方法间的协调问题。

比如不需要考虑不能同时写入或读写不能并行的问题，也不需要考虑任何额外的同步问题。
比如不需要额外自己加 synchronized 锁，那么它才是线程安全的。

2.浅谈活跃性问题？

活跃性问题就是程序始终得不到运行的最终结果，比如发生死锁会导致程序完全卡死，无法向下运行。

死锁

死锁是指两个线程之间相互等待对方资源，但同时又互不相让，都想自己先执行。

package org.example.thread;

/**
 * @author cf
 * @date 2022/12/3 14:57
 * @description 死锁例子
 */
public class MayDeadLock {

    Object o1 = new Object();
    Object o2 = new Object();

    public void thread1() throws InterruptedException {
        synchronized (o1) {
            Thread.sleep(500);
            synchronized (o2) {
                System.out.println("线程1成功拿到两把锁");
            }
        }
    }

    public void thread2() throws InterruptedException {
        synchronized (o2) {
            Thread.sleep(500);
            synchronized (o1) {
                System.out.println("线程2成功拿到两把锁");
            }
        }
    }

    public static void main(String[] args) {
        MayDeadLock mayDeadLock = new MayDeadLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    mayDeadLock.thread1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    mayDeadLock.thread2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

首先，代码中创建了两个 Object 作为 synchronized 锁的对象，线程 1 先获取 o1 锁，sleep(500) 之后，获取 o2 锁；
线程 2 与线程 1 执行顺序相反，先获取 o2 锁，sleep(500) 之后，获取 o1 锁。
假设两个线程几乎同时进入休息，休息完后，线程 1 想获取 o2 锁，线程 2 想获取 o1 锁，这时便发生了死锁，两个线程不主动调和，也不主动退出，就这样死死地等待对方先释放资源，导致程序得不到任何结果也不能停止运行。
运行没有结果。

活锁

锁与死锁非常相似，也是程序一直等不到结果，但对比于死锁，活锁是活的。

因为正在运行的线程并没有阻塞，它始终在运行中，却一直得不到结果。

举一个例子，假设有一个消息队列，队列里放着各种各样需要被处理的消息，而某个消息由于自身被写错了导致不能被正确处理，执行时会报错，可是队列的重试机制会重新把它放在队列头进行优先重试处理，但这个消息本身无论被执行多少次，都无法被正确处理，每次报错后又会被放到队列头进行重试，周而复始，最终导致线程一直处于忙碌状态，但程序始终得不到结果，便发生了活锁问题。