深入理解多线程编程陷阱:数据竞争、死锁、活锁与饥饿的分析与解决

最新推荐文章于 2024-09-10 06:51:09 发布

何综瑞

最新推荐文章于 2024-09-10 06:51:09 发布

阅读量836

点赞数 11

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/m0_72877724/article/details/140389511

版权

多线程编程确实存在许多常见的陷阱,了解这些问题并掌握避免的方法对于编写高质量的并发程序至关重要。让我为您详细讲解几个主要的陷阱,并提供相应的代码示例和避免方法。

1.数据竞争(Data Race)

数据竞争是指多个线程同时访问同一块内存,且至少有一个线程进行写操作的情况。这可能导致不可预测的结果。

示例代码:

#include <thread>
#include <iostream>

int shared_data = 0;

void increment() {
    for (int i = 0; i < 1000000; ++i) {
        shared_data++; // 潜在的数据竞争
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    
    t1.join();
    t2.join();
    
    std::cout << "Final value: " << shared_data << std::endl;
    return 0;
}

避免方法:

使用互斥锁(mutex)保护共享数据
使用原子操作
避免共享可变状态,尽量使用不可变数据

修正后的代码:

#include <thread>
#include <mutex>
#include <iostream>

int shared_data = 0;
std::mutex mtx;

void increment() {
    for (int i = 0; i < 1000000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        shared_data++;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    
    t1.join();
    t2.join();
    
    std::cout << "Final value: " << shared_data << std::endl;
    return 0;
}

2.死锁(Deadlock)

死锁发生在两个或多个线程互相等待对方释放资源,导致所有相关线程都无法继续执行。

示例代码:

#include <thread>
#include <mutex>
#include <iostream>

std::mutex mutex1, mutex2;

void thread1_function() {
    std::lock_guard<std::mutex> lock1(mutex1);
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    std::lock_guard<std::mutex> lock2(mutex2);
    std::cout << "Thread 1 acquired both mutexes" << std::endl;
}

void thread2_function() {
    std::lock_guard<std::mutex> lock2(mutex2);
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    std::lock_guard<std::mutex> lock1(mutex1);
    std::cout << "Thread 2 acquired both mutexes" << std::endl;
}

int main() {
    std::thread t1(thread1_function);
    std::thread t2(thread2_function);
    
    t1.join();
    t2.join();
    
    return 0;
}

避免方法:

始终以相同的顺序获取锁
使用 std::lock 同时锁定多个互斥量
使用层次锁 (hierarchical mutex)
尽量减少嵌套锁的使用

修正后的代码:

#include <thread>
#include <mutex>
#include <iostream>

std::mutex mutex1, mutex2;

void thread_function(int thread_id) {
    std::lock(mutex1, mutex2);
    std::lock_guard<std::mutex> lock1(mutex1, std::adopt_lock);
    std::lock_guard<std::mutex> lock2(mutex2, std::adopt_lock);
    std::cout << "Thread " << thread_id << " acquired both mutexes" << std::endl;
}

int main() {
    std::thread t1(thread_function, 1);
    std::thread t2(thread_function, 2);
    
    t1.join();
    t2.join();
    
    return 0;
}

3.活锁(Livelock)

活锁是指线程持续响应彼此的行为,但无法向前推进。这通常发生在线程试图避免死锁时。

示例代码:

#include <thread>
#include <mutex>
#include <iostream>
#include <chrono>

class Philosopher {
private:
    std::mutex& left_fork;
    std::mutex& right_fork;
public:
    Philosopher(std::mutex& left, std::mutex& right) : left_fork(left), right_fork(right) {}
    
    void dine() {
        while (true) {
            if (left_fork.try_lock()) {
                if (right_fork.try_lock()) {
                    std::cout << "Philosopher is eating" << std::endl;
                    left_fork.unlock();
                    right_fork.unlock();
                    return;
                } else {
                    left_fork.unlock();
                }
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
};

int main() {
    std::mutex fork1, fork2;
    Philosopher philosopher1(fork1, fork2);
    Philosopher philosopher2(fork2, fork1);
    
    std::thread t1(&Philosopher::dine, &philosopher1);
    std::thread t2(&Philosopher::dine, &philosopher2);
    
    t1.join();
    t2.join();
    
    return 0;
}

避免方法:

引入随机性或退避策略
使用优先级或资源分配策略
重新设计并发算法以避免循环依赖

修正后的代码:

#include <thread>
#include <mutex>
#include <iostream>
#include <chrono>
#include <random>

class Philosopher {
private:
    std::mutex& left_fork;
    std::mutex& right_fork;
    std::mt19937 rng;
public:
    Philosopher(std::mutex& left, std::mutex& right) : left_fork(left), right_fork(right) {
        std::random_device rd;
        rng = std::mt19937(rd());
    }
    
    void dine() {
        std::uniform_int_distribution<> dist(1, 100);
        while (true) {
            if (left_fork.try_lock()) {
                if (right_fork.try_lock()) {
                    std::cout << "Philosopher is eating" << std::endl;
                    left_fork.unlock();
                    right_fork.unlock();
                    return;
                } else {
                    left_fork.unlock();
                }
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(dist(rng)));
        }
    }
};

int main() {
    std::mutex fork1, fork2;
    Philosopher philosopher1(fork1, fork2);
    Philosopher philosopher2(fork2, fork1);
    
    std::thread t1(&Philosopher::dine, &philosopher1);
    std::thread t2(&Philosopher::dine, &philosopher2);
    
    t1.join();
    t2.join();
    
    return 0;
}

4.饥饿(Starvation)

饥饿发生在一个或多个线程无法获得所需资源,导致无法继续执行的情况。通常是由于其他线程长时间占用资源造成的。

示例代码:

#include <thread>
#include <mutex>
#include <iostream>
#include <chrono>

std::mutex resource_mutex;

void high_priority_thread() {
    while (true) {
        std::lock_guard<std::mutex> lock(resource_mutex);
        std::cout << "High priority thread is using the resource" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void low_priority_thread() {
    while (true) {
        if (resource_mutex.try_lock()) {
            std::cout << "Low priority thread is using the resource" << std::endl;
            resource_mutex.unlock();
            return;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main() {
    std::thread t1(high_priority_thread);
    std::thread t2(low_priority_thread);
    
    t2.join();  // 等待低优先级线程完成
    t1.detach();  // 分离高优先级线程
    
    return 0;
}

避免方法:

使用公平锁或读写锁
实现资源分配策略,如优先级调度
使用条件变量或信号量来协调资源访问

修正后的代码:

#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>
#include <chrono>
#include <queue>

std::mutex resource_mutex;
std::condition_variable cv;
std::queue<int> task_queue;

void producer() {
    for (int i = 0; i < 10; ++i) {
        {
            std::lock_guard<std::mutex> lock(resource_mutex);
            task_queue.push(i);
            std::cout << "Produced: " << i << std::endl;
        }
        cv.notify_one();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void consumer(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(resource_mutex);
        cv.wait(lock, [] { return !task_queue.empty(); });
        int task = task_queue.front();
        task_queue.pop();
        std::cout << "Consumer " << id << " consumed: " << task << std::endl;
        if (task == 9) return;  // End condition
    }
}

int main() {
    std::thread prod(producer);
    std::thread cons1(consumer, 1);
    std::thread cons2(consumer, 2);
    
    prod.join();
    cons1.join();
    cons2.join();
    
    return 0;
}

总结:
多线程编程中的这些陷阱可能导致程序行为不可预测、性能下降甚至完全失效。通过使用适当的同步机制、遵循良好的设计原则以及仔细考虑线程间的交互,我们可以有效地避免这些问题。重要的是要理解每种陷阱的本质,并在设计和实现并发程序时时刻保持警惕。