Linux C++如何处理多线程同步问题

在Linux环境下使用C++进行多线程编程时，处理线程同步是一个重要的问题。线程同步的目的是确保多个线程能够安全地访问共享资源，避免数据竞争和不一致性。以下是一些常用的线程同步机制：

1. 互斥锁（Mutex）

互斥锁是最基本的同步机制之一，用于保护共享资源。

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

std::mutex mtx;
     // 全局互斥锁
int shared_data = 0;


void increment() {
    
    mtx.lock();
     // 加锁
    ++shared_data;
    
    mtx.unlock();
 // 解锁
}


int main() {
    
    std::thread t1(increment);
    
    std::thread t2(increment);
    

    t1.join();
    
    t2.join();
    

    std::cout <
    <
     "Shared data: " <
    <
     shared_data <
    <
     std::endl;
    
    return 0;

}
    

2. 递归互斥锁（Recursive Mutex）

递归互斥锁允许同一个线程多次锁定同一个互斥锁，而不会导致死锁。

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

std::recursive_mutex mtx;
     // 全局递归互斥锁
int shared_data = 0;


void increment(int count) {
    
    if (count <
    = 0) return;
    
    mtx.lock();
     // 加锁
    ++shared_data;
    
    increment(count - 1);
     // 递归调用
    mtx.unlock();
 // 解锁
}


int main() {
    
    std::thread t1(increment, 10);
    
    std::thread t2(increment, 10);
    

    t1.join();
    
    t2.join();
    

    std::cout <
    <
     "Shared data: " <
    <
     shared_data <
    <
     std::endl;
    
    return 0;

}
    

3. 条件变量（Condition Variable）

条件变量用于线程间的等待和通知机制。

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

std::mutex mtx;
    
std::condition_variable cv;
    
bool ready = false;


void worker() {
    
    std::unique_lock<
    std::mutex>
     lock(mtx);

    cv.wait(lock, []{
     return ready;
 }
    );
     // 等待条件变量
    std::cout <
    <
     "Worker thread is processing data\n";

}


void trigger() {
    
    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
    
        std::lock_guard<
    std::mutex>
     lock(mtx);
    
        ready = true;

    }
    
    cv.notify_one();
 // 通知一个等待的线程
}


int main() {
    
    std::thread t1(worker);
    
    std::thread t2(worker);
    

    trigger();
    

    t1.join();
    
    t2.join();
    

    return 0;

}
    

4. 读写锁（Reader-Writer Lock）

读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。

#include <
    iostream>
    
#include <
    thread>
    
#include <
    shared_mutex>
    

std::shared_mutex rw_mtx;
     // 全局读写锁
int shared_data = 0;


void reader() {
    
    std::shared_lock<
    std::shared_mutex>
     lock(rw_mtx);
     // 读锁
    std::cout <
    <
     "Reading data: " <
    <
     shared_data <
    <
     std::endl;

}


void writer() {
    
    std::unique_lock<
    std::shared_mutex>
     lock(rw_mtx);
     // 写锁
    ++shared_data;
    
    std::cout <
    <
     "Writing data: " <
    <
     shared_data <
    <
     std::endl;

}


int main() {
    
    std::thread t1(reader);
    
    std::thread t2(writer);
    
    std::thread t3(reader);
    

    t1.join();
    
    t2.join();
    
    t3.join();
    

    return 0;

}
    

5. 原子操作（Atomic Operations）

原子操作可以在不使用锁的情况下实现线程安全的操作。

#include <
    iostream>
    
#include <
    thread>
    
#include <
    atomic>
    

std::atomic<
    int>
     shared_data(0);


void increment() {
    
    ++shared_data;
 // 原子操作
}


int main() {
    
    std::thread t1(increment);
    
    std::thread t2(increment);
    

    t1.join();
    
    t2.join();
    

    std::cout <
    <
     "Shared data: " <
    <
     shared_data <
    <
     std::endl;
    
    return 0;

}
    

选择合适的同步机制取决于具体的应用场景和需求。在实际编程中，可能需要结合多种同步机制来实现复杂的线程同步逻辑。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！