【多线程】常见问题简单总结

灰太狼 2024-02-05 20:09 20阅读 0赞

![5bcca03a06ac4b78a1464179aae767ca.gif][]

**目录**

1. 竞态条件（Race Condition）

场景:

解决方法:

2. 死锁（Deadlock）

场景:

解决方法:

3. 线程饥饿（Thread Starvation）

场景:

解决方法:

4. 活锁（Livelock）

场景:

解决方法:

--------------------

多线程编程在提高程序性能方面非常有用，但也引入了一系列常见问题，主要包括竞态条件、死锁、线程饥饿和活锁等。以下是这些问题的解释以及如何在Java中解决它们的例子。

## 1. 竞态条件（Race Condition） ##

竞态条件发生在两个或多个线程访问共享资源并尝试同时修改它时。这可能导致不一致和不可预测的结果。

#### **场景**: ####

*  **共享资源**: 当多个线程访问和修改同一个变量或资源，而没有适当的同步措施时。
 *  **非原子操作**: 操作如递增一个计数器，这需要读取、修改和写入值，这些步骤在没有同步的情况下会被中断。
 *  **先检查后执行**: 先检查资源状态，然后根据状态执行操作的模式，如果状态在检查和执行之间被另一个线程改变，会导致问题。

#### 解决方法: ####

使用同步机制，如synchronized关键字或显式锁（如\`ReentrantLock\`），来确保一次只有一个线程可以访问共享资源。

Java 示例

public class Counter {
        private int count = 0;
    
        public synchronized void increment() {
            count++;
        }
    
        public synchronized int getCount() {
            return count;
        }
    }

## 2. 死锁（Deadlock） ##

死锁是指两个或多个线程永远等待对方释放锁的情况。这通常发生在每个线程都持有一个锁并尝试获取其他线程已持有的锁时。

#### **场景**: ####

*  **互斥条件**: 程序中的多个线程需要同时锁定多个资源。
 *  **请求和保持条件**: 线程已经持有至少一个资源，并且正在等待获取额外的资源，这些资源可能被其他已经锁定了它们的线程持有。
 *  **不剥夺条件**: 资源被线程持有，直到自愿释放，不能被强制剥夺。
 *  **循环等待条件**: 发生在一组线程中，每个线程都在等待下一个线程所持有的资源。

#### 解决方法: ####

避免嵌套锁，使用定时锁（尝试锁），或者以一致的顺序获取锁。

Java 示例

public class Account {
        private int balance = 10000;
    
        // Transfer method with ordered locks to avoid deadlock
        public void transfer(Account from, Account to, int amount) {
            synchronized (from) { // First lock
                synchronized (to) { // Second lock
                    if (from.balance >= amount) {
                        from.balance -= amount;
                        to.balance += amount;
                    }
                }
            }
        }
    }

## 3. 线程饥饿（Thread Starvation） ##

线程饥饿发生在低优先级的线程长时间得不到执行，因为高优先级的线程一直占用CPU资源。

#### **场景**: ####

*  **优先级不当**: 当一个高优先级的线程不断地被调度，而低优先级的线程得不到足够的CPU时间。
 *  **锁的不当使用**: 长时间持有锁，特别是在执行耗时操作时，可能会导致其他线程长时间等待。
 *  **线程数量过多**: 当线程的数量远远超过处理器的数量，导致某些线程很少获得CPU时间。

#### 解决方法: ####

使用公平锁（如\`ReentrantLock\`的公平模式），或者调整线程优先级，确保低优先级线程也能获得执行时间。

Java 示例

import java.util.concurrent.locks.ReentrantLock;
    
    public class FairLockExample {
        private final ReentrantLock lock = new ReentrantLock(true); // Fair lock
    
        public void fairMethod() {
            lock.lock();
            try {
                // Critical section code
            } finally {
                lock.unlock();
            }
        }
    }

## 4. 活锁（Livelock） ##

活锁是指线程虽然没有被阻塞，但也无法向前推进因为不断重复相同的操作，通常是因为线程间的相互响应。

#### **场景**: ####

*  **错误的失败恢复策略**: 当线程尝试执行一个操作失败后，它会尝试重试相同的操作，而这个操作由于某些外部条件总是失败。
 *  **过度响应**: 当两个线程或更多线程设计为响应对方的动作时，它们可能会陷入一个循环，其中每个线程都在尝试避免与其他线程发生冲突。

#### 解决方法: ####

引入随机性，例如在重试之前等待随机的时间，或者改变重试的策略。

Java 示例

public class LivelockExample {
        private boolean isActive;
    
        public synchronized void attemptAction() {
            while (isActive) {
                // 线程在这里尝试某个操作，但失败了
                try {
                    Thread.sleep((long) (Math.random() * 100)); // 随机等待
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                // 一些其他的逻辑，可能会改变isActive的状态
            }
        }
    
        public synchronized void setActive(boolean active) {
            isActive = active;
        }
    }

在多线程编程时，始终要确保对共享资源的访问是适当同步的，同时要留意代码中可能导致死锁或活锁的设计。还应该避免对线程优先级的依赖，因为这可能会在不同的平台上导致不同的行为。

在设计多线程程序时，理解这些问题及其出现的场景是非常重要的。这有助于程序员采取预防措施，比如使用适当的同步机制、设计合理的线程优先级和锁策略，以及实现健壮的错误处理和恢复策略。通过这些措施，可以大大减少多线程应用程序中出现问题的可能性。

![6201cd58a5e74bda9f9df976bbe0200b.gif][]

**有用请点赞，养成良好习惯！**

**疑问、交流、鼓励请留言！**

[5bcca03a06ac4b78a1464179aae767ca.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/a5f9b2dcddf949c9b318fcf0771df98a.png
[6201cd58a5e74bda9f9df976bbe0200b.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/1ade024fcec34362a6240ff3d5dffcbd.png