首页 > 编程语言 >C++在Ubuntu上如何实现并发编程

C++在Ubuntu上如何实现并发编程

来源：互联网 2026-04-20 11:43:33

在Ubuntu上使用C++进行并发编程在Ubuntu系统中，利用C++进行并发编程是提升程序执行效率和处理能力的关键途径。现代C++标准库提供了一系列强大的并发编程工具，使得开发者能够更便捷地实现并行处理。本文将介绍几种主流的并发实现方法，并附上可直接运行的代码示例，帮助您快速上手。 1. 多线程

在Ubuntu上使用C++进行并发编程

在Ubuntu系统中，利用C++进行并发编程是提升程序执行效率和处理能力的关键途径。现代C++标准库提供了一系列强大的并发编程工具，使得开发者能够更便捷地实现并行处理。本文将介绍几种主流的并发实现方法，并附上可直接运行的代码示例，帮助您快速上手。

C++在Ubuntu上如何实现并发编程

长期稳定更新的攒劲资源： >>>点此立即查看<<<

1. 多线程：任务并行化的基础

多线程是实现并发编程的基础。C++11标准引入的头文件简化了线程的创建与管理。开发者只需定义一个函数，并将其传递给std::thread对象即可创建新线程。

#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()显式控制锁，可以防止多个线程的输出相互干扰。但需注意避免因忘记解锁而导致死锁，因此更推荐使用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 (int i = 0; i < 10; ++i)
        threads[i] = std::thread(printId, i);

    std::cout << "10 threads ready to race..." << std::endl;
    go(); // 触发条件

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

此示例模拟了多个线程等待同一信号后同时执行的场景。std::unique_lock与条件变量结合，实现了线程的安全挂起与唤醒。

4. 原子操作：轻量级且无锁的同步

对于简单的变量操作，使用互斥锁可能带来不必要的性能开销。库提供的原子类型能够确保操作的不可分割性，以更低代价实现线程安全。

#include 
#include 
#include 

std::atomic counter(0);

void incrementCounter() {
    for (int i = 0; i < 100000; ++i) {
        counter++; // 原子操作
    }
}

int main() {
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

原子操作保证了计数结果的准确性，它是构建高性能无锁并发数据结构的基础。

5. 异步任务：让结果在未来到来

和std::async允许将耗时任务异步执行，并在需要时获取结果，从而避免阻塞主线程。

#include 
#include 

int asyncFunction() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时操作
    return 42;
}

int main() {
    std::future result = std::async(std::launch::async, asyncFunction);
    std::cout << "Waiting for the result..." << std::endl;
    int value = result.get(); // 获取异步结果
    std::cout << "Result: " << value << std::endl;
    return 0;
}

这种模式适用于I/O密集型或计算密集型任务，能有效提升程序的响应速度。

6. 信号量：控制并发访问的流量

标准C++库尚未直接提供信号量，但在Linux/Ubuntu环境下，可以使用POSIX标准的。信号量常用于限制同时访问特定资源的线程数量。

#include 
#include 
#include 

sem_t sem;

void worker() {
    sem_wait(&sem); // 等待信号量
    std::cout << "Worker thread is running" << std::endl;
    sem_post(&sem); // 释放信号量
}

int main() {
    sem_init(&sem, 0, 0); // 初始化信号量，初始值为0
    std::thread t(worker);
    std::cout << "Main thread is doing some work..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟工作
    sem_post(&sem); // 释放信号量，允许工作线程运行
    t.join();
    sem_destroy(&sem); // 销毁信号量
    return 0;
}

在此示例中，工作线程等待主线程完成准备工作并释放信号量后才开始执行。