C++并发编程 thread基本使用方法-C++-PHP中文网

std::thread是C++并发编程的基础，用于创建和管理线程，需手动调用join()或detach()管理生命周期，避免数据竞争应使用互斥量，传递引用需用std::ref，获取结果可结合std::promise与std::future，而C++20的std::jthread提供了自动管理线程生命周期的改进。

c++并发编程 thread基本使用方法

C++并发编程中，

std::thread

登录后复制

无疑是基石。它允许我们将程序的执行流拆分成独立的、同时运行的线程，从而更好地利用多核处理器，提升程序的响应速度和吞吐量。简单来说，

std::thread

登录后复制

就是你在C++里开启一个新任务的直接方式，让它和主程序并行执行。它提供了一种底层、灵活的机制来管理并发任务，虽然在使用上需要我们多一些考量，但其提供的强大能力是构建高性能应用不可或缺的。

解决方案

使用

std::thread

登录后复制

开启一个新线程，核心在于提供一个可调用对象（callable object）作为线程的入口点。这个可调用对象可以是普通函数、Lambda表达式、函数对象（functor）甚至是类的成员函数。

要使用

std::thread

登录后复制

，首先需要包含

<thread>

登录后复制

头文件。

1. 创建并启动线程

立即进入“豆包AI人工智官网入口”；

立即学习“豆包AI人工智能在线问答入口”；

最直接的方式是传递一个函数名或Lambda表达式给

std::thread

登录后复制

的构造函数。

#include <iostream>
#include <thread>
#include <string>
#include <chrono> // 用于std::this_thread::sleep_for

// 普通函数作为线程入口
void worker_function(int id, const std::string& message) {
    std::cout << "Thread " << id << ": " << message << " (Running on core "
              << std::this_thread::get_id() << ")" << std::endl;
    // 模拟一些工作
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "Thread " << id << " finished." << std::endl;
}

// 函数对象（Functor）作为线程入口
class FunctorWorker {
public:
    void operator()(int id) {
        std::cout << "Functor Thread " << id << " is running." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(300));
        std::cout << "Functor Thread " << id << " finished." << std::endl;
    }
};

int main() {
    std::cout << "Main thread started." << std::endl;

    // 方式一：使用普通函数
    // 传递给线程函数的参数，会在线程创建时被拷贝一份
    std::thread t1(worker_function, 1, "Hello from function");

    // 方式二：使用Lambda表达式
    // Lambda捕获的变量也会被拷贝（如果不是引用捕获）
    std::thread t2([](int id, const std::string& msg) {
        std::cout << "Lambda Thread " << id << ": " << msg << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        std::cout << "Lambda Thread " << id << " finished." << std::endl;
    }, 2, "Greetings from lambda");

    // 方式三：使用函数对象（Functor）
    FunctorWorker fw;
    std::thread t3(fw, 3); // 注意：fw会被拷贝到线程对象内部

    // 方式四：使用类的成员函数（需要对象实例和成员函数指针）
    // 这种方式稍微复杂一些，需要将对象实例的指针或引用作为第一个参数传递
    class MyClass {
    public:
        void member_func(int id) {
            std::cout << "Member Function Thread " << id << " is running." << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            std::cout << "Member Function Thread " << id << " finished." << std::endl;
        }
    };
    MyClass obj;
    std::thread t4(&MyClass::member_func, &obj, 4); // &obj 是对象实例的指针

    // ... 线程管理 ...
    // 务必在线程对象生命周期结束前调用 join() 或 detach()
    // 否则，程序会在 std::thread 析构时调用 std::terminate 终止。

    // 等待线程完成
    t1.join(); // 主线程会阻塞，直到t1完成
    t2.join(); // 主线程会阻塞，直到t2完成
    t3.join(); // 主线程会阻塞，直到t3完成
    t4.join(); // 主线程会阻塞，直到t4完成

    std::cout << "Main thread finished. All threads joined." << std::endl;
    return 0;
}

登录后复制

2. 线程的管理：

join()

登录后复制

与
detach()
登录后复制

这是

std::thread

登录后复制

使用中一个非常关键的环节。一个

std::thread

登录后复制

对象在析构时，如果它仍然是“可joinable”的（即代表着一个仍在运行的线程，并且没有被

join()

登录后复制

或

detach()

登录后复制

），程序会调用

std::terminate

登录后复制

终止。这意味着我们必须显式地处理线程的生命周期。

```
join()
```
登录后复制
:
- ```
t.join();
```
  登录后复制
  的作用是让当前线程（通常是主线程）等待
```
t
```
  登录后复制
  所代表的线程执行完毕。
- 一旦
```
join()
```
  登录后复制
  被调用，
```
t
```
  登录后复制
  就不再是可joinable的了。
- 这是一种同步机制，确保子线程的工作在主线程继续执行前完成。
- 适用于你需要子线程的结果，或者需要确保子线程在某个时间点之前完成所有清理工作的情况。
```
detach()
```
登录后复制
:
- ```
t.detach();
```
  登录后复制
  的作用是将
```
t
```
  登录后复制
  所代表的线程从
```
std::thread
```
  登录后复制
  对象中分离。
- 分离后，该线程成为一个后台线程（daemon thread），独立运行，不再与
```
std::thread
```
  登录后复制
  对象关联。
- 主线程不再关心其执行状态，也不会等待它结束。
- 当后台线程完成时，其资源会自动被操作系统回收。
- 适用于“发后即忘”的场景，比如记录日志、发送通知等，不需要主线程等待结果。
- 分离后，
```
t
```
  登录后复制
  也不再是可joinable的了。

3. 线程参数传递

默认情况下，传递给线程函数的参数都是按值拷贝的。这意味着即使你的函数签名是按引用接收，传递给

std::thread

登录后复制

构造函数的参数也会被拷贝一份，然后将这份拷贝的引用传递给线程函数。

如果你确实想按引用传递参数，需要使用

std::ref

登录后复制

或

std::cref

登录后复制

(对于const引用)。

#include <iostream>
#include <thread>
#include <string>
#include <vector>
#include <numeric> // for std::accumulate
#include <functional> // for std::ref

void accumulate_sum(const std::vector<int>& data, long long& result) {
    result = std::accumulate(data.begin(), data.end(), 0LL);
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    long long sum_result = 0;

    // 如果不使用 std::ref，sum_result 会被拷贝，线程修改的是拷贝，而不是外部的 sum_result
    std::thread t(accumulate_sum, std::ref(numbers), std::ref(sum_result));

    t.join();

    std::cout << "Accumulated sum: " << sum_result << std::endl; // 输出 55
    return 0;
}

登录后复制

这里，

std::ref(numbers)

登录后复制

和

std::ref(sum_result)

登录后复制

确保了

accumulate_sum

登录后复制

函数能够直接访问并修改

main

登录后复制

函数中的

numbers

登录后复制

向量和

sum_result

登录后复制

变量。

C++

std::thread

登录后复制

并发编程中，有哪些常见的陷阱和最佳实践？

在使用

std::thread

登录后复制

时，一些看似微小的疏忽都可能导致程序崩溃、数据损坏或难以调试的并发问题。这就像你第一次尝试驾驶手动挡汽车，理论上你知道怎么操作，但实际驾驶中总有些地方让你手忙脚乱。

一个最直接的陷阱就是未处理的线程生命周期。前面提到了，如果一个

std::thread

登录后复制

对象在析构时仍然是可joinable的，程序会直接

std::terminate

登录后复制

。这通常发生在线程还在运行，但主线程或创建它的作用域已经退出，而你又忘记

join()

登录后复制

或

detach()

登录后复制

它。解决方案很简单：确保每个

std::thread

登录后复制

对象在生命周期结束前，要么被

join()

登录后复制

（等待其完成），要么被

detach()

登录后复制

（让其独立运行）。一个常用的模式是在一个

try-catch

登录后复制

块中创建线程，并在

finally

登录后复制

（或C++中的RAII析构函数）中

join()

登录后复制

它，以确保即使发生异常也能正确处理。

另一个核心问题是数据竞争（Data Race）。当多个线程同时访问并修改同一个共享资源（比如一个全局变量、一个类的成员变量、一个

std::vector

登录后复制

）时，如果没有适当的同步机制，程序的行为将是未定义的。这可能导致数据错乱、计算错误，甚至程序崩溃。比如，两个线程同时对一个计数器进行

++

登录后复制

操作，最终结果可能不是你预期的加倍。解决数据竞争的“万金油”是使用互斥量（
std::mutex
登录后复制
）。在访问共享资源之前加锁，访问之后解锁，确保同一时间只有一个线程能修改该资源。

std::lock_guard

登录后复制

或

std::unique_lock

登录后复制

是更推荐的RAII（Resource Acquisition Is Initialization）方式，它们能自动管理锁的释放，即使在异常发生时也能保证锁被正确释放。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

#include <iostream>
#include <thread>
#include <mutex> // for std::mutex and std::lock_guard
#include <vector>

std::mutex mtx; // 全局互斥量
int shared_counter = 0;

void increment_counter() {
    for (int i = 0; i < 10000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 自动加锁，作用域结束自动解锁
        shared_counter++;
    }
}

int main() {
    std::thread t1(increment_counter);
    std::thread t2(increment_counter);

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

    std::cout << "Final counter value: " << shared_counter << std::endl; // 期望是 20000
    return 0;
}

登录后复制

如果没有

std::lock_guard

登录后复制

，

shared_counter

登录后复制

很可能不会是20000。

此外，异常安全也是一个值得关注的点。如果一个线程函数在

join()

登录后复制

之前抛出了异常，而你没有捕获，那么

std::thread

登录后复制

对象可能在析构时仍然是可joinable的，再次导致

std::terminate

登录后复制

。通常的做法是在线程函数内部捕获并处理异常，或者将异常信息传递回主线程（例如通过

std::promise

登录后复制

std::future

登录后复制

）。

最后，性能考量。虽然多线程旨在提升性能，但线程的创建、销毁、上下文切换以及锁的开销都可能抵消其带来的好处。创建过多的线程，或者线程之间的竞争过于激烈，反而可能导致性能下降。所以，设计并发程序时，要合理分配任务，尽量减少共享状态，并选择合适的同步原语。

如何在

std::thread

登录后复制

中安全地传递复杂参数与获取结果？

安全地传递参数和获取结果是多线程编程中一个核心的挑战。如果你只是传递基本类型，通常不会有太多问题，因为它们会被拷贝。但当涉及引用、大对象、所有权转移或异步结果时，就需要更精细的策略。

1. 传递引用：使用

std::ref

登录后复制

和
std::cref
登录后复制

前面已经展示过，

std::thread

登录后复制

构造函数默认会对参数进行拷贝。如果你想让线程函数修改主线程中的变量，或者避免大对象的拷贝开销，就需要显式地使用

std::ref

登录后复制

（对于可修改的引用）或

std::cref

登录后复制

（对于常量引用）。它们将参数包装成一个引用包装器，确保线程函数接收到的是原始对象的引用。

#include <iostream>
#include <thread>
#include <string>
#include <functional> // For std::ref

void modify_string(std::string& s) {
    s += " (modified by thread)";
}

int main() {
    std::string original_str = "Hello Thread";
    std::cout << "Before thread: " << original_str << std::endl;

    std::thread t(modify_string, std::ref(original_str));
    t.join();

    std::cout << "After thread: " << original_str << std::endl; // 输出修改后的字符串
    return 0;
}

登录后复制

2. 传递移动语义对象：使用

std::move

登录后复制

对于那些不支持拷贝但支持移动（Move-only types）的对象，例如

std::unique_ptr

登录后复制

、

std::thread

登录后复制

本身、

std::ofstream

登录后复制

等，你需要使用

std::move

登录后复制

来将它们的所有权转移给新线程。这避免了不必要的拷贝，也符合这些资源管理类的设计哲学。

#include <iostream>
#include <thread>
#include <memory> // For std::unique_ptr

void process_unique_ptr(std::unique_ptr<int> ptr) {
    if (ptr) {
        std::cout << "Thread received unique_ptr with value: " << *ptr << std::endl;
    } else {
        std::cout << "Thread received a null unique_ptr." << std::endl;
    }
}

int main() {
    auto my_ptr = std::make_unique<int>(42);
    std::cout << "Main thread unique_ptr value: " << *my_ptr << std::endl;

    // 将 my_ptr 的所有权转移给新线程
    std::thread t(process_unique_ptr, std::move(my_ptr));
    t.join();

    // 此时 my_ptr 在主线程中已经失效，不再拥有资源
    if (!my_ptr) {
        std::cout << "Main thread's unique_ptr is now null." << std::endl;
    }
    return 0;
}

登录后复制

3. 获取线程执行结果：

std::promise

登录后复制

和
std::future
登录后复制

std::thread

登录后复制

本身没有直接的返回值机制。如果你需要从子线程获取计算结果，

std::promise

登录后复制

和

std::future

登录后复制

是C++标准库提供的强大工具。

```
std::promise
```
登录后复制
：用于在线程中设置一个值或异常。
```
std::future
```
登录后复制
：从
```
std::promise
```
登录后复制
获取结果。它是一个异步结果的占位符，你可以通过
```
get()
```
登录后复制
方法等待并获取结果。

#include <iostream>
#include <thread>
#include <future> // For std::promise and std::future
#include <numeric>
#include <vector>

void calculate_sum_async(std::promise<long long> p, const std::vector<int>& data) {
    try {
        long long sum = std::accumulate(data.begin(), data.end(), 0LL);
        p.set_value(sum); // 设置结果
    } catch (...) {
        p.set_exception(std::current_exception()); // 捕获并传递异常
    }
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::promise<long long> sum_promise;
    std::future<long long> sum_future = sum_promise.get_future(); // 获取未来结果的句柄

    std::thread t(calculate_sum_async, std::move(sum_promise), numbers); // 移动 promise

    // 主线程可以做其他事情...
    std::cout << "Main thread doing other work..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));

    // 等待并获取结果
    try {
        long long result = sum_future.get(); // get() 会阻塞直到结果可用
        std::cout << "Async sum result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error in thread: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

登录后复制

这种模式非常优雅，它将结果的生产和消费解耦，允许主线程在等待结果的同时执行其他任务。

std::thread

登录后复制

、

std::async

登录后复制

与

std::jthread

登录后复制

：C++并发工具箱的选择考量

C++标准库为我们提供了多种并发工具，

std::thread

登录后复制

只是其中最基础的一员。随着C++版本的迭代，出现了

std::async

登录后复制

（C++11）和

std::jthread

登录后复制

（C++20），它们在不同程度上简化了并发编程。理解它们之间的差异，能帮助我们根据具体需求做出更明智的选择。

std::thread

登录后复制

：底层、灵活但需手动管理

特点：
```
std::thread
```
登录后复制
是创建新执行流的最低级抽象。它直接映射到操作系统线程，给你最大的控制权。
优点：
- 极致的控制：你可以完全控制线程的创建、启动和生命周期。
- 适用场景：需要长期运行的后台服务线程、线程池的底层实现、对线程行为有特殊需求的场景。
缺点：
- 手动管理：必须手动处理
```
join()
```
  登录后复制
  或
```
detach()
```
  登录后复制
  ，否则程序可能崩溃。这很容易出错，尤其是与异常处理结合时。
- 无直接返回值：获取线程结果需要借助
```
std::promise
```
  登录后复制
  /
```
std::future
```
  登录后复制
  或其他同步机制。
- 资源管理：需要自己处理线程的资源释放。