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

红太狼 2023-10-08 17:14 71阅读 0赞

## 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();
        }
    }

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

### 活锁 ###

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

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

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

### 饥饿 ###

**饥饿是指线程需要某些资源时始终得不到，尤其是CPU 资源，就会导致线程一直不能运行而产生的问题。**

在 Java 中有线程优先级的概念，Java 中优先级分为 1 到 10，1 最低，10 最高。

如果我们把某个线程的优先级设置为 1，这是最低的优先级，在这种情况下，这个线程就有可能始终分配不到 CPU 资源，而导致长时间无法运行。

或者是某个线程始终持有某个文件的锁，而其他线程想要修改文件就必须先获取锁，这样想要修改文件的线程就会陷入饥饿，长时间不能运行。