C++如何在Linux中实现并发

C++在Linux中实现并发的几种核心方法

想在Linux环境下让C++程序跑得更快、处理能力更强？并发编程是绕不开的关键技术。好消息是，现代C++标准库已经为我们提供了一整套相当完善的并发工具，让开发者能够相对轻松地驾驭多线程、同步等复杂场景。下面就来梳理一下几种最常用、也最核心的实现方式。

1. 多线程：一切并发的起点

说到并发，首先想到的自然是多线程。自C++11起，标准库引入了头文件，创建和管理线程变得前所未有的简单。不再需要依赖平台特定的API，用标准写法就能轻松拉起一个新线程。

#include 
#include 

void helloFunction() {
    std::cout << "Hello from a thread!" << std::endl;
}

int main() {
    std::thread t(helloFunction);
    t.join(); // 等待线程完成
    return 0;
}

看，几行代码就完成了一个线程从创建到执行再到回收的全过程。join()调用确保了主线程会等待工作线程结束，避免了程序提前退出导致的问题。

2. 互斥锁：守护共享资源的卫士

多个线程一旦开始运行，数据共享就成了一个甜蜜的烦恼。如果缺乏保护，对同一块数据的并发读写很容易导致数据竞争，结果往往不可预测。这时候，互斥锁就该登场了。库提供了最基本的锁机制，确保同一时间只有一个线程能进入临界区。

#include 
#include 
#include 

std::mutex mtx; // 创建一个互斥锁

void printMessage(const std::string& msg) {
    mtx.lock(); // 加锁
    std::cout << msg << std::endl;
    mtx.unlock(); // 解锁
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");
    t1.join();
    t2.join();
    return 0;
}

不过需要留意，直接使用lock()和unlock()需要格外小心，万一在加锁后、解锁前发生了异常，可能会导致锁无法释放。更推荐的做法是使用std::lock_guard或std::unique_lock这类RAII风格的包装器，让锁的生命周期自动管理。

3. 条件变量：线程间的“信号灯”

有时候，线程需要等待某个条件成立才能继续执行，而不是盲目地轮询消耗CPU。条件变量就是为解决这类同步问题而生的。它允许一个或多个线程挂起等待，直到另一个线程通知条件发生变化。

#include 
#include 
#include 
#include 

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

void printId(int id) {
    std::unique_lock lck(mtx);
    cv.wait(lck, []{return ready;}); // 等待条件变量
    std::cout << "Thread " << id << std::endl;
}

void go() {
    std::lock_guard lck(mtx);
    ready = true;
    cv.notify_all(); // 通知所有等待的线程
}

int main() {
    std::thread threads[10];
    for (auto& th : threads)
        th = std::thread(printId, &th - &threads[0]);

    std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待一段时间
    go(); // 发出信号

    for (auto& th : threads)
        th.join();
    return 0;
}

这个例子模拟了一个经典的“发令枪”场景：10个线程各就各位，等待一个统一的启动信号。条件变量与互斥锁、谓词（这里的ready标志）配合使用，是构建高效生产者-消费者模型等复杂同步模式的基础。

4. 原子操作：轻量级的并发利器

对于简单的计数器、状态标志这类操作，使用重量级的锁机制可能有些“杀鸡用牛刀”。C++11引入的库提供了原子类型，能够在无需显式加锁的情况下，保证对特定数据的读写操作是原子的、线程安全的。

#include 
#include 
#include 

std::atomic counter(0);

void incrementCounter() {
    for (int i = 0; i < 100000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed); // 原子加法
    }
}

int main() {
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter.load() << std::endl; // 输出计数器的值
    return 0;
}

原子操作的性能通常远高于互斥锁。但要注意，它主要适用于对单个变量的简单操作。对于涉及多个变量需要保持一致性（事务性）的复杂操作，仍然需要依靠锁或其他同步机制。

5. 异步编程：让任务在后台静默执行

有些任务耗时较长，但又不想阻塞主线程。这时候，异步编程模型就派上用场了。和允许我们启动一个异步任务，并在未来的某个时刻获取其结果，非常适合于I/O操作、复杂计算等场景。

#include 
#include 

int calculateSum(int a, int b) {
    return a + b;
}

int main() {
    auto future = std::async(std::launch::async, calculateSum, 5, 7); // 异步执行
    std::cout << "Waiting for result..." << std::endl;
    int sum = future.get(); // 获取结果
    std::cout << "The sum is: " << sum << std::endl;
    return 0;
}

std::async的启动策略（std::launch::async）确保了任务会在新线程中执行。主线程通过future.get()获取结果时，如果任务尚未完成，则会自动等待。这种“发起后不管，需要时再取”的模式，能极大地简化并发代码的编写。

6. 信号量：控制并发访问的经典工具

最后提一下信号量。虽然C++标准库至今仍未直接提供信号量，但在Linux平台上，我们可以直接使用POSIX标准定义的信号量（semaphore.h）。信号量本质上是一个计数器，用于控制对有限数量资源的访问，是解决多线程同步问题的又一利器。

#include 
#include 
#include 

sem_t sem;

void workerThread() {
    sem_wait(&sem); // 等待信号量
    std::cout << "Worker thread is processing..." << std::endl;
    sem_post(&sem); // 发送信号量
}

int main() {
    sem_init(&sem, 0, 0); // 初始化信号量，初始值为0
    std::thread t(workerThread);
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待一段时间
    sem_post(&sem); // 发送信号量，允许工作线程继续
    t.join();
    sem_destroy(&sem); // 销毁信号量
    return 0;
}

在这个例子中，工作线程在启动后会因信号量初始值为0而阻塞在sem_wait处。主线程在延时后通过sem_post增加信号量，从而“释放”工作线程。这种模式常用于线程池、限流等场景。

以上就是C++在Linux环境下实现并发的几种基本方法。实际开发中，这些技术往往不是孤立使用的。根据具体的性能要求、复杂度和应用场景，灵活地组合运用它们，才能构建出既高效又健壮的并发程序。从简单的多线程到精细的同步控制，现代C++已经为我们提供了足够强大的工具箱，剩下的，就是如何巧妙地运用它们了。