C++线程安全：共享数据的完美守护者("C++线程安全技巧：如何高效守护共享数据")

原创

ithorizon 4个月前 (10-19) 阅读数 17 #后端开发

C++线程可靠：共享数据的完美守护者

在多线程编程中，共享数据是致使程序失误和性能问题的关键因素之一。合理地管理和同步共享数据，是确保程序正确性和高效性的关键。本文将深入探讨C++中守护共享数据的一些技巧和方法。

1. 明白线程可靠的挑战

线程可靠的核心问题在于多个线程也许同时访问和修改同一块内存。这也许致使以下几种常见的问题：

竞态条件（Race Conditions）

死锁（Deadlocks）

资源饥饿（Resource Starvation）

2. 互斥锁（Mutex）

互斥锁是保护共享数据最常用的方法。互斥锁可以保证在同一时刻只有一个线程可以访问共享数据。


#include 
#include 
#include 
std::mutex mtx; // 创建互斥锁
void shared_print(const std::string& msg, int id) {
    mtx.lock(); // 锁定互斥锁
    // 执行需要保护的代码
    std::cout << msg << id << std::endl;
    mtx.unlock(); // 解锁互斥锁
}
int main() {
    std::thread t1(shared_print, "Thread 1: ", 1);
    std::thread t2(shared_print, "Thread 2: ", 2);
    t1.join();
    t2.join();
    return 0;
}

3. 递归互斥锁

当函数可以递归调用时，普通互斥锁也许会出现问题。递归互斥锁允许同一个线程多次锁定互斥锁。


#include 
#include 
#include 
std::recursive_mutex recursive_mtx; // 创建递归互斥锁
void recursive_function(int id) {
    recursive_mtx.lock();
    std::cout << "Thread " << id << " entered recursive function." << std::endl;
    recursive_function(id); // 递归调用
    recursive_mtx.unlock();
}
int main() {
    std::thread t(recursive_function, 1);
    t.join();
    return 0;
}

4. 条件变量（Condition Variables）

条件变量通常与互斥锁一起使用，用于线程间的同步。当某个条件不满足时，线程可以等待，直到条件被另一个线程触发。


#include 
#include 
#include 
#include 
std::mutex cv_mtx;
std::condition_variable cv;
bool ready = false;
void prepare() {
    std::unique_lock lk(cv_mtx);
    ready = true;
    cv.notify_one(); // 通知等待的线程
}
void process() {
    std::unique_lock lk(cv_mtx);
    cv.wait(lk, []{return ready;}); // 等待条件满足
    std::cout << "Processing is done." << std::endl;
}
int main() {
    std::thread t1(prepare);
    std::thread t2(process);
    t1.join();
    t2.join();
    return 0;
}

5. 原子操作（Atomic Operations）

原子操作可以保证操作的不可分割性，从而避免使用互斥锁。C++11引入了原子操作库，提供了一系列原子类型。


#include 
#include 
#include 
std::atomic counter(0);
void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed); // 原子加操作
    }
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    std::cout << "Counter value is: " << counter << std::endl;
    return 0;
}

6. 读写锁（Read-Write Lock）

读写锁允许多个线程同时读取数据，但写入时需要独占访问。这可以减成本时间程序的性能。


#include 
#include 
#include 
std::shared_mutex rw_mtx;
int shared_data = 0;
void read_data(int id) {
    std::shared_lock lock(rw_mtx);
    std::cout << "Thread " << id << " reads data: " << shared_data << std::endl;
}
void write_data(int id) {
    std::unique_lock lock(rw_mtx);
    ++shared_data;
    std::cout << "Thread " << id << " writes data: " << shared_data << std::endl;
}
int main() {
    std::thread t1(read_data, 1);
    std::thread t2(write_data, 2);
    std::thread t3(read_data, 3);
    t1.join();
    t2.join();
    t3.join();
    return 0;
}

7. 线程局部存储（Thread-Local Storage）

线程局部存储为每个线程提供自由的变量副本，从而避免共享数据。


#include 
#include 
#include 
thread_local int var = 0;
void increment() {
    ++var;
    std::cout << "Thread " << std::this_thread::get_id() << " var: " << var << std::endl;
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    return 0;
}