std::thread是C++并发编程的基础，用于创建和管理线程，需手动调用join()或detach()管理生命周期，避免数据竞争应使用互斥量，传递引用需用std::ref，获取结果可结合std::promise与std::future，而C++20的std::jthread提供了自动管理线程生命周期的改进。
C++并发编程中，
std::thread
无疑是基石。它允许我们将程序的执行流拆分成独立的、同时运行的线程，从而更好地利用多核处理器，提升程序的响应速度和吞吐量。简单来说，
std::thread
就是你在C++里开启一个新任务的直接方式，让它和主程序并行执行。它提供了一种底层、灵活的机制来管理并发任务，虽然在使用上需要我们多一些考量，但其提供的强大能力是构建高性能应用不可或缺的。
解决方案
使用
std::thread
开启一个新线程，核心在于提供一个可调用对象（callable object）作为线程的入口点。这个可调用对象可以是普通函数、Lambda表达式、函数对象（functor）甚至是类的成员函数。
要使用
std::thread
，首先需要包含
头文件。
1. 创建并启动线程
立即学习“C++免费学习笔记（深入）”；
最直接的方式是传递一个函数名或Lambda表达式给
std::thread
的构造函数。
#include #include #include #include // 用于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 #include #include #include #include // for std::accumulate#include // for std::refvoid accumulate_sum(const std::vector& data, long long& result) { result = std::accumulate(data.begin(), data.end(), 0LL);}int main() { std::vector 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
时，一些看似微小的疏忽都可能导致程序崩溃、数据损坏或难以调试的并发问题。这就像你第一次尝试驾驶手动挡汽车，理论上你知道怎么操作，但实际驾驶中总有些地方让你手忙脚乱。
一个最直接的陷阱就是未处理的线程生命周期。前面提到了，如果一个
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）方式，它们能自动管理锁的释放，即使在异常发生时也能保证锁被正确释放。
#include #include #include // for std::mutex and std::lock_guard#include std::mutex mtx; // 全局互斥量int shared_counter = 0;void increment_counter() { for (int i = 0; i < 10000; ++i) { std::lock_guard 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
std::thread
中安全地传递复杂参数与获取结果？
安全地传递参数和获取结果是多线程编程中一个核心的挑战。如果你只是传递基本类型，通常不会有太多问题，因为它们会被拷贝。但当涉及引用、大对象、所有权转移或异步结果时，就需要更精细的策略。
1. 传递引用：使用
std::ref
和
std::cref
前面已经展示过，
std::thread
构造函数默认会对参数进行拷贝。如果你想让线程函数修改主线程中的变量，或者避免大对象的拷贝开销，就需要显式地使用
std::ref
（对于可修改的引用）或
std::cref
（对于常量引用）。它们将参数包装成一个引用包装器，确保线程函数接收到的是原始对象的引用。
#include #include #include #include // For std::refvoid 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 #include #include // For std::unique_ptrvoid process_unique_ptr(std::unique_ptr 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(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
std::promise
：用于在线程中设置一个值或异常。
std::future
：从
std::promise
获取结果。它是一个异步结果的占位符，你可以通过
get()
方法等待并获取结果。
#include #include #include // For std::promise and std::future#include #include void calculate_sum_async(std::promise p, const std::vector& 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 numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; std::promise sum_promise; std::future 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::thread
、
std::async
与
std::jthread
：C++并发工具箱的选择考量
C++标准库为我们提供了多种并发工具，
std::thread
只是其中最基础的一员。随着C++版本的迭代，出现了
std::async
（C++11）和
std::jthread
（C++20），它们在不同程度上简化了并发编程。理解它们之间的差异，能帮助我们根据具体需求做出更明智的选择。
1.
std::thread
：底层、灵活但需手动管理
特点：
std::thread
是创建新执行流的最低级抽象。它直接映射到操作系统线程，给你最大的控制权。优点：极致的控制：你可以完全控制线程的创建、启动和生命周期。适用场景：需要长期运行的后台服务线程、线程池的底层实现、对线程行为有特殊需求的场景。缺点：手动管理：必须手动处理
join()
或
detach()
，否则程序可能崩溃。这很容易出错，尤其是与异常处理结合时。无直接返回值：获取线程结果需要借助
std::promise
/
std::future
或其他同步机制。资源管理：需要自己处理线程的资源释放。
**2
以上就是C++并发编程 thread基本使用方法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1474458.html
微信扫一扫 
支付宝扫一扫 
