C++ 多线程编程的实现方式

在 C++ 中，实现多线程编程的方法有很多，从底层到高层大致可以分为以下几类。

方式	标准	是否推荐	适用场景
POSIX Threads (`pthread`)	POSIX	⭐⭐⭐⭐	Linux/Unix 系统开发
`std::thread`	C++11	⭐⭐⭐⭐⭐	现代 C++ 首选
`std::async`	C++11	⭐⭐⭐	简单异步任务
OpenMP	编译器扩展	⭐⭐⭐⭐⭐	科学计算、循环并行
Intel TBB / oneTBB	第三方库	⭐⭐⭐⭐	任务并行
Boost.Thread	Boost	⭐⭐⭐	老项目兼容
Qt QThread	Qt	⭐⭐⭐⭐	Qt GUI 程序
MPI	第三方库	⭐	多进程，不属于线程库

注意最后一项 MPI 不是线程库 ，而是进程并行库。

1. std::thread（现代 C++ 首选）

C++11 开始标准提供。

cpp 复制代码

#include <thread>
#include <iostream>

void work(int id)
{
    std::cout << id << std::endl;
}

int main()
{
    std::thread t1(work, 1);
    std::thread t2(work, 2);

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

优点：

跨平台
STL 风格
推荐新项目使用

配套还有：

cpp 复制代码

std::mutex
std::lock_guard
std::unique_lock
std::condition_variable
std::atomic
std::future

2. pthread（Linux 最经典）

这是 Linux 系统接口。

cpp 复制代码

#include <pthread.h>

void* func(void*)
{
    return nullptr;
}

int main()
{
    pthread_t tid;

    pthread_create(&tid, nullptr, func, nullptr);

    pthread_join(tid, nullptr);
}

优点：

Linux 下功能最完整
很多老项目都在用

缺点：

C 风格 API
使用起来比较繁琐

很多 std::thread 的实现底层实际上会调用 pthread（在 Linux 上）。

3. std::async

适合执行一个异步任务。

cpp 复制代码

auto result = std::async(std::launch::async,
                         []()
                         {
                             return 100;
                         });

std::cout << result.get();

不需要自己创建线程。

4. OpenMP（科学计算最常见）

例如：

cpp 复制代码

#pragma omp parallel for
for(int i=0;i<N;i++)
{
    a[i]+=b[i];
}

编译：

bash 复制代码

g++ -fopenmp

OpenMP 特点：

几乎不用管理线程
编译器自动完成

VASP、LAMMPS、OpenFOAM 都大量使用。

例如：

cpp 复制代码

#pragma omp parallel
{
    // 多线程
}

5. Intel TBB（oneTBB）

Intel 的任务调度库。

例如：

cpp 复制代码

tbb::parallel_for(
    0,
    N,
    [&](int i)
    {
        ...
    });

比 OpenMP 更灵活。

很多工业软件使用：

OpenCV
oneAPI

6. Boost.Thread

现代 C++ 出现以前最流行。

cpp 复制代码

boost::thread t(func);

现在基本被：

cpp 复制代码

std::thread

替代。

7. Qt 的 QThread

Qt GUI 开发必备。

例如：

cpp 复制代码

class Worker : public QThread
{
    void run() override
    {
        ...
    }
};

主要解决：

GUI 不阻塞
信号槽

8. 线程池（Thread Pool）

严格来说不是一种线程 API，而是一种编程模式。

例如：

cpp 复制代码

ThreadPool pool(8);

pool.enqueue(task1);
pool.enqueue(task2);

优点：

避免频繁创建线程
性能最好

很多服务器都采用这种方式。

C++23 标准没有正式线程池，很多项目使用：

BS::thread_pool
oneTBB
folly
Boost.Asio

9. MPI（容易和线程混淆）

MPI：

cpp 复制代码

MPI_Init(...);

MPI_Comm_rank(...);

MPI_Send(...);

它创建的是：

text 复制代码

Process0
Process1
Process2

不是：

text 复制代码

Thread1
Thread2

所以：

MPI 是多进程，不是多线程。

在 HPC 中通常是混合并行

像 VASP、GROMACS 等 HPC 软件通常会组合使用多种技术：

text 复制代码

多个节点
    │
    ▼
 MPI（多进程）
    │
    ▼
OpenMP（每个进程多个线程）
    │
    ▼
CUDA/HIP（GPU 并行）

例如：

text 复制代码

Node1
 ├── MPI Rank0
 │      ├── Thread0
 │      ├── Thread1
 │      └── Thread2
 └── MPI Rank1
        ├── Thread0
        ├── Thread1
        └── GPU0

因此，一个 VASP 作业中通常会同时用到 MPI + OpenMP + CUDA/HIP，分别负责不同层次的并行。

实际工作中的常见选择

如果按行业来看，大致可以这样归纳：

普通 C++ 应用开发 ：std::thread 是首选，Linux 老项目中 pthread 仍然很多。
科学计算 / HPC：OpenMP + MPI 是主流，GPU 场景再结合 CUDA/HIP。
GUI 开发（Qt） ：通常使用 QThread。
高性能服务器：更多使用线程池、任务调度库（如 oneTBB、Boost.Asio、folly 等），而不是频繁创建和销毁线程。

这张表有一定误导性。MPI 和 OpenMP 并不是"见得少"，而是它们主要集中在科学计算和 HPC 领域；在通用 C++ 应用、服务端和 GUI 开发中相对少见。

另外，现代 C++ 新项目通常优先使用 std::thread，并不是普遍优先使用 pthread。pthread 更多见于 Linux 系统软件、底层运行时和历史项目。

先区分三种并行模型

技术	并行单位	内存模型	典型范围
`pthread` / `std::thread`	线程	共享内存	单个进程、单台机器
OpenMP	线程	共享内存	单进程、单个计算节点
MPI	进程	分布式内存、消息传递	单节点或多个计算节点

MPI 不是线程库。它主要解决：

text 复制代码

节点 A 的进程如何和节点 B 的进程交换数据

OpenMP 和线程库主要解决：

text 复制代码

同一进程内多个 CPU 核心如何共享数据并行计算

为什么通用 C++ 项目中 MPI 不常见

MPI 主要面向多进程、分布式内存计算。例如超算中：

text 复制代码

计算节点 0：MPI rank 0～63
计算节点 1：MPI rank 64～127
计算节点 2：MPI rank 128～191

进程之间通过消息通信：

cpp 复制代码

MPI_Send(...);
MPI_Recv(...);
MPI_Allreduce(...);

它特别适合：

VASP、LAMMPS、GROMACS 等科学计算；
流体、气象、量子化学计算；
大规模矩阵和网格计算；
跨多个服务器或超算节点运行。

普通桌面程序、Web 服务或 GUI 程序通常不需要同时使用几十台服务器做一次紧密耦合计算，因此很少使用 MPI。

另外，MPI 程序通常需要专门启动：

bash 复制代码

mpirun -np 64 ./program

它的进程部署、通信、负载均衡和故障处理也比普通线程复杂。

所以不是 MPI 不成熟，而是它解决的问题与普通多线程不同。在 HPC 中，MPI 非常常见，甚至可以说是基础设施。

为什么通用 C++ 中 OpenMP 看起来也不多

OpenMP 最擅长的是规则循环并行：

cpp 复制代码

#pragma omp parallel for
for (int i = 0; i < n; ++i) {
    c[i] = a[i] + b[i];
}

这类代码在科学计算中很多，因此 OpenMP 非常合适。

但通用 C++ 程序的并发任务通常不是规则循环，例如：

网络连接处理；
后台任务队列；
文件异步读写；
GUI 后台计算；
长生命周期工作线程；
生产者/消费者；
线程池；
复杂任务依赖。

这些场景通常需要显式控制：

text 复制代码

创建线程
等待线程
条件变量
互斥锁
任务队列
线程生命周期
异常和退出

std::thread、std::jthread、线程池或异步框架更适合这些需求。

OpenMP 的优势是快速表达"把这一段计算并行化"，而不是构建完整的并发软件架构。

为什么有些 C++ 项目使用 pthread

pthread 是 POSIX 线程接口，长期以来是 Linux/Unix 的底层线程标准：

c 复制代码

pthread_create(...);
pthread_join(...);
pthread_mutex_lock(...);

它常见的原因主要有以下几个。

1. 历史原因

C++11 以前，标准 C++ 没有正式的线程库。Linux C/C++ 项目普遍使用 pthread。许多成熟项目延续了原有设计。

2. 同时支持 C 和 C++

pthread 是 C 接口，可以被 C 和 C++ 使用。操作系统、数据库和底层库经常包含大量 C 代码。

3. Linux 平台的底层控制

pthread 提供一些平台相关能力，例如：

c 复制代码

pthread_setaffinity_np
pthread_setschedparam
pthread_setname_np

可用于：

CPU 亲和性；
实时调度策略；
线程栈大小；
线程名称；
NUMA 和性能调优。

虽然 C++ 标准线程可以通过 native_handle() 获取底层 pthread，但底层系统软件有时会直接使用 pthread。

4. 很多高级线程库最终建立在 pthread 上

在 Linux 中：

text 复制代码

std::thread
OpenMP runtime
oneTBB
各种线程池
        ↓
通常最终使用 pthread/clone 创建系统线程

因此 pthread 是底层机制，而 OpenMP、oneTBB 和 std::thread 是更高级的编程接口。

新 C++ 项目该用什么

如果是普通现代 C++ 项目，通常优先：

cpp 复制代码

#include <thread>

std::thread t([] {
    // 工作
});
t.join();

C++20 中更推荐考虑 std::jthread：

cpp 复制代码

#include <thread>

std::jthread t([] {
    // 工作
});

std::jthread 析构时自动等待线程，还支持协作式停止，比直接管理 std::thread 更安全。

只有在以下场景才更可能直接使用 pthread：

项目主体是 C；
必须兼容较老的 C++ 标准；
强依赖 POSIX 接口；
需要精细控制线程调度、栈和亲和性；
正在维护已有 pthread 项目。

OpenMP 和普通线程的核心差异

假设要并行处理数组。

使用 OpenMP：

cpp 复制代码

#pragma omp parallel for
for (int i = 0; i < n; ++i) {
    c[i] = a[i] + b[i];
}

程序员描述的是：

这个循环可以并行。

使用线程库时：

cpp 复制代码

std::vector<std::thread> threads;

for (int t = 0; t < num_threads; ++t) {
    threads.emplace_back([&, t] {
        int begin = t * n / num_threads;
        int end = (t + 1) * n / num_threads;

        for (int i = begin; i < end; ++i) {
            c[i] = a[i] + b[i];
        }
    });
}

for (auto& thread : threads) {
    thread.join();
}

程序员需要自己处理：

创建多少线程；
每个线程处理哪一段；
如何捕获变量；
如何等待线程结束。

因此对于规则数值循环，OpenMP 更简洁；对于复杂并发架构，显式线程或任务系统更灵活。

MPI、OpenMP 经常一起使用

在超算中，典型模式不是二选一，而是混合并行：

text 复制代码

多个计算节点
    ↓ MPI
每个节点启动若干 MPI 进程
    ↓ OpenMP
每个 MPI 进程再启动若干 CPU 线程

例如两台节点，每台 64 核：

text 复制代码

每节点 4 个 MPI 进程
每个 MPI 进程 16 个 OpenMP 线程
总计：2 × 4 × 16 = 128 个 CPU 核

常见启动方式类似：

bash 复制代码

export OMP_NUM_THREADS=16
mpirun -np 8 ./program

VASP 就经常采用 MPI、OpenMP 和 GPU 加速的组合。

对原表的修正

更合理的评价是：

技术	定位	推荐场景
`std::thread` / `std::jthread`	标准 C++ 线程	现代通用 C++
pthread	POSIX 底层线程	C、Linux 系统开发、底层控制
OpenMP	标准化共享内存并行 API	科学计算、规则循环
oneTBB	任务并行运行时	复杂任务图、线程池
MPI	分布式进程通信标准	集群、超算、多节点计算

另外，OpenMP 不是简单的"编译器私有扩展"，它有独立的公开规范，只是通过编译器指令和运行时库实现。

一句话总结：

普通 C++ 并发优先考虑标准线程或成熟任务框架；规则科学计算优先考虑 OpenMP；跨节点并行使用 MPI；pthread 更接近 Linux 底层实现和控制接口。