Linux C++程序如何实现并发控制

在Linux环境下用C++搞并发，方法其实挺多的。选哪种，关键得看你的具体场景。下面咱们就聊聊几种常见的并发控制机制，并配上可以直接跑起来的代码示例。

免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈

1. 使用互斥锁（Mutex）

互斥锁，可以说是并发编程里的“老大哥”了。它的任务很明确：保护共享资源，确保同一时间只有一个线程能碰它。这能有效防止数据竞争，但用不好也容易导致死锁。

#include 
#include 
#include 

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;
}

看这段代码，两个线程t1和t2都想增加shared_data。没有锁的话，结果可能出乎意料；有了mtx这把锁，就能保证每次加法操作都是原子的。不过要提醒一点，手动调用lock()和unlock()需要格外小心，万一在锁中间抛个异常或者忘了解锁，就麻烦了。所以更常见的做法是使用std::lock_guard。

2. 使用递归互斥锁（Recursive Mutex）

普通互斥锁有个特点：同一个线程重复上锁会导致死锁。那如果函数会递归调用自己，或者需要多层加锁呢？这时候递归互斥锁就派上用场了。它允许同一个线程多次获得锁，只要解锁次数匹配就行。

#include 
#include 
#include 

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

void increment(int count) {
    if (count <= 0) return;
    mtx.lock();   // 加锁
    ++shared_data;
    std::cout << "Thread " << std::this_thread::get_id() << " incremented shared_data to " << shared_data << std::endl;
    mtx.unlock(); // 解锁
    increment(count - 1); // 递归调用
}

int main() {
    std::thread t1(increment, 5);
    std::thread t2(increment, 3);
    t1.join();
    t2.join();
    std::cout << "Final shared data: " << shared_data << std::endl;
    return 0;
}

这个例子里，increment函数会递归调用自己。如果用普通mutex，线程第一次进入函数锁上后，在递归调用时试图再次获取锁，就会把自己永远挂起。换成recursive_mutex就顺畅了。当然，递归锁通常比普通锁开销大一点，非必要不使用。

3. 使用条件变量（Condition Variable）

条件变量解决的是另一类问题：线程间的协同等待。比如，一个线程需要等待某个条件成立（比如数据准备好了）才能继续，而另一个线程负责在条件满足时通知它。这是实现生产者-消费者模型的核心工具之一。

#include 
#include 
#include 
#include 

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

void worker() {
    std::unique_lock lock(mtx);
    cv.wait(lock, []{ return ready; }); // 等待条件成立
    std::cout << "Worker thread is processing data..." << std::endl;
}

void trigger() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟一些准备工作
    {
        std::lock_guard lock(mtx);
        ready = true;
    }
    cv.notify_one(); // 通知一个等待的线程
}

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

注意看cv.wait的用法，它接受一个锁和一个谓词（lambda表达式）。这样写可以防止“虚假唤醒”——即条件变量可能因为系统原因而返回，但条件并未真正满足。使用谓词判断，就能确保唤醒时条件一定为真。另外，通知线程在修改条件变量关联的布尔标志ready时，也必须在锁的保护下进行，这是标准做法。

4. 使用原子操作（Atomic Operations）

如果共享的操作非常简单，比如只是对一个整数进行加减，那么上锁就显得有点“杀鸡用牛刀”了，性能开销不小。这时候，原子类型就是更好的选择。它在底层通过CPU指令保证操作的不可分割性，既安全又高效。

#include 
#include 
#include 

std::atomic 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;
}

代码简洁多了，不是吗？std::atomic保证了++shared_data这个操作是原子的，无需额外锁。原子操作非常适合计数器、状态标志等简单场景。但要注意，它只能保证单个操作的原子性；如果需要保护多个相关联变量的修改，或者一个复杂的临界区，还是得靠互斥锁。

5. 使用读写锁（Read-Write Lock）

最后来看一种更精细的锁策略：读写锁。它基于一个很常见的观察——读操作往往远多于写操作，而且读操作之间通常不会冲突。读写锁（C++17中的std::shared_mutex）允许多个线程同时读，但写操作是独占的。这能在读多写少的场景下大幅提升并发性能。

#include 
#include 
#include 

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

void reader() {
    std::shared_lock lock(rw_mtx); // 上读锁
    std::cout << "Reader thread read shared_data: " << shared_data << std::endl;
}

void writer() {
    std::unique_lock lock(rw_mtx); // 上写锁
    ++shared_data;
    std::cout << "Writer thread wrote shared_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;
}

这里的关键在于锁的类型：读线程使用std::shared_lock，这意味着多个读锁可以共存；写线程使用std::unique_lock，它和普通的互斥锁一样是独占的。当有写锁存在时，所有读锁和写锁请求都必须等待。这种机制完美适配了配置读取、缓存访问等场景。

好了，以上就是Linux C++并发编程中几种核心的同步机制。从最基础的互斥锁，到应对特殊场景的递归锁，再到用于线程协作的条件变量，以及追求性能极致的原子操作和读写锁，每种工具都有其用武之地。实际开发中，往往需要根据数据访问模式、性能要求和代码复杂度来灵活选择和组合。理解它们的特性和代价，是写出稳健高效并发程序的第一步。