1. 线程基础概念解析
在C++11标准之前，C++语言本身并不直接支持多线程编程，开发者不得不依赖平台特定的API（如Windows的CreateThread或POSIX的pthread_create）来实现并发功能。这种状况直到2011年C++11标准的发布才得到根本改变——标准库正式引入了
线程（Thread）本质上是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。与进程相比，线程的最大特点是共享相同的地址空间，这使得线程间通信变得非常高效，但也带来了同步和数据竞争等复杂问题。
关键区别：进程是资源分配的基本单位，而线程是CPU调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的全局变量和堆内存，但每个线程拥有独立的栈空间。
在C++中，std::thread类的构造函数接受一个可调用对象（函数、lambda表达式、函数对象等）作为参数，这个可调用对象就是线程的入口函数。当thread对象被构造时，操作系统会立即创建一个新的执行线程来运行这个函数。
cpp复制#include <iostream>
#include <thread>
void hello() {
std::cout << "Hello from thread!\n";
}
int main() {
std::thread t(hello); // 创建并启动线程
t.join(); // 等待线程结束
return 0;
}
2. 线程生命周期管理
2.1 线程创建与启动
C++线程的生命周期从std::thread对象构造时开始。与许多其他语言不同，C++中的线程在构造完成后立即开始执行，没有单独的"start"方法。这种设计体现了C++"零开销抽象"的理念，避免了不必要的函数调用开销。
线程构造函数的参数传递遵循普通函数调用的规则，但有一些特殊注意事项：
- 参数总是被拷贝到线程的内部存储中
- 如果需要传递引用，必须使用std::ref显式包装
- 对于成员函数，需要同时传递对象实例指针
cpp复制// 传递参数的例子
void print_value(int value) {
std::cout << "Value: " << value << "\n";
}
std::thread t(print_value, 42); // 值传递
// 传递引用的例子
void modify_value(int& value) {
value *= 2;
}
int main() {
int x = 10;
std::thread t(modify_value, std::ref(x)); // 引用传递
t.join();
std::cout << x; // 输出20
}
2.2 线程等待与分离
线程对象有两种主要的结束处理方式：join()和detach()。join()会阻塞当前线程，直到目标线程执行完毕；detach()则会将线程分离，使其变为后台线程，不再受thread对象控制。
重要规则：在thread对象销毁前，必须调用join()或detach()，否则程序会调用std::terminate()终止。这是C++线程模型中的硬性要求。
分离线程(detach)的典型使用场景包括：
- 长时间运行的后台任务
- 不需要等待结果的异步操作
- 需要独立于主程序生命周期的情况
cpp复制// 分离线程的例子
void background_task() {
// 长时间运行的任务...
}
int main() {
std::thread t(background_task);
t.detach(); // 分离线程
// 主线程可以立即继续执行
// 注意：分离后不能再与t交互
}
3. 线程标识与硬件并发
3.1 线程标识符
每个线程都有唯一的标识符，可以通过std::thread::get_id()获取。主线程的ID可以通过std::this_thread::get_id()获得。这些ID在调试和日志记录中非常有用。
cpp复制std::thread::id master_thread_id = std::this_thread::get_id();
void check_thread() {
if (std::this_thread::get_id() == master_thread_id) {
std::cout << "This is the master thread\n";
} else {
std::cout << "This is a worker thread\n";
}
}
3.2 硬件并发支持
std::thread::hardware_concurrency()返回当前系统支持的真正并发线程数（通常是CPU核心数）。这个值对于设计线程池和任务调度非常有用。
cpp复制unsigned int cores = std::thread::hardware_concurrency();
std::cout << "This system can run " << cores << " threads truly concurrently.\n";
在实际编程中，创建比硬件并发数多得多的线程通常不会带来性能提升，反而可能因为上下文切换开销而降低性能。最佳实践是根据硬件并发数设计线程数量。
4. 线程传参的陷阱与技巧
4.1 参数传递的常见问题
线程参数传递看似简单，实则暗藏多个陷阱：
- 悬垂引用问题：当传递局部变量的引用或指针时，必须确保线程不会在变量生命周期结束后访问它。
cpp复制// 错误示例：悬垂引用
void bad_practice() {
int local = 42;
std::thread t([&](){
// 可能访问已销毁的local
std::cout << local;
});
t.detach();
} // local被销毁，但线程可能仍在运行
-
对象切片问题：当传递派生类对象作为基类参数时，会发生对象切片。
-
不可拷贝对象问题：某些对象（如unique_ptr）不可拷贝，需要特殊处理。
4.2 安全传参的最佳实践
-
值传递优先：对于小型简单类型，优先使用值传递。
-
智能指针传递：对于需要在堆上分配的对象，使用shared_ptr或unique_ptr。
cpp复制void process_data(std::unique_ptr<Data> data) {
// 处理数据
}
int main() {
auto data = std::make_unique<Data>();
std::thread t(process_data, std::move(data)); // 使用移动语义
t.join();
}
-
使用std::ref显式传递引用：当确实需要传递引用时，使用std::ref明确表达意图。
-
lambda捕获注意事项：在lambda中捕获变量时，注意值捕获和引用捕获的区别。
5. 线程局部存储
线程局部存储（Thread Local Storage, TLS）允许每个线程拥有变量的独立副本。C++11通过thread_local关键字支持这一特性。
cpp复制thread_local int counter = 0; // 每个线程有自己的counter副本
void increment() {
++counter; // 只修改当前线程的副本
std::cout << "Thread " << std::this_thread::get_id()
<< ": " << counter << "\n";
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
// 输出可能是：
// Thread 123: 1
// Thread 456: 1
}
thread_local变量的初始化对于每个线程都是独立的，且只会在线程首次访问变量时进行。常见的应用场景包括：
- 线程特定的随机数生成器
- 错误状态变量
- 递归锁的计数
- 需要避免锁的性能关键路径上的变量
6. 线程异常处理
线程中的异常不会自动传播到创建它的线程中。如果线程函数抛出异常且未被捕获，程序会调用std::terminate()终止。因此，良好的线程代码应该包含全面的异常处理。
cpp复制void might_throw() {
throw std::runtime_error("Oops!");
}
void safe_thread_function() {
try {
might_throw();
} catch (const std::exception& e) {
std::cerr << "Thread caught: " << e.what() << "\n";
}
}
int main() {
std::thread t(safe_thread_function);
t.join();
}
对于需要将异常传递回主线程的场景，可以考虑以下方法：
- 使用std::promise和std::future组合
- 使用共享变量（需要同步）存储异常信息
- 使用第三方库如Boost.Exception
7. 线程与RAII模式
资源获取即初始化（RAII）是C++的核心范式，也适用于线程管理。我们可以创建ThreadGuard类来确保线程在作用域结束时总是被join或detach。
cpp复制class ThreadGuard {
std::thread& t;
public:
explicit ThreadGuard(std::thread& t_) : t(t_) {}
~ThreadGuard() {
if (t.joinable()) {
t.join(); // 或根据需求改为detach()
}
}
ThreadGuard(const ThreadGuard&) = delete;
ThreadGuard& operator=(const ThreadGuard&) = delete;
};
void use_guard() {
std::thread t([](){ /*...*/ });
ThreadGuard g(t);
// 即使这里抛出异常，线程也会被正确join
}
这种模式特别适合在可能抛出异常的代码块中管理线程，确保不会因为异常导致线程未被正确处理。
8. 性能考量与最佳实践
8.1 线程创建开销
虽然现代操作系统和C++标准库对线程创建做了大量优化，但创建线程仍然是有开销的。典型情况下，线程创建需要：
- 分配栈空间（通常几MB）
- 设置线程上下文
- 系统调用开销
因此，对于需要大量短期任务的场景，应该考虑：
- 使用线程池复用线程
- 使用更轻量级的任务机制（如C++17的std::async）
- 批量处理任务
8.2 栈大小管理
每个线程都有独立的栈空间，默认大小取决于平台（Linux通常8MB，Windows通常1MB）。对于需要大量栈空间或创建大量线程的场景，可以调整栈大小：
cpp复制// 设置线程栈大小（平台特定）
std::thread t([](){ /*...*/ });
pthread_t handle = t.native_handle();
pthread_attr_t attr;
pthread_getattr_np(handle, &attr);
pthread_attr_setstacksize(&attr, 16*1024*1024); // 16MB
8.3 CPU亲和性设置
在多核系统中，可以通过设置CPU亲和性（affinity）来优化线程调度：
cpp复制// 设置线程CPU亲和性（Linux示例）
void set_affinity(std::thread& t, int cpu) {
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(cpu, &cpuset);
pthread_setaffinity_np(t.native_handle(), sizeof(cpu_set_t), &cpuset);
}
这种优化通常用于：
- 减少缓存失效
- 确保关键线程独占核心
- NUMA架构下的性能优化
9. 跨平台注意事项
虽然C++标准线程库旨在提供跨平台支持，但在实际使用中仍需注意平台差异：
- 线程优先级：设置方法因平台而异
- 线程命名：调试时有用，但API不统一
- 信号处理：不同平台对信号与线程的交互方式不同
- 错误处理：某些错误条件在不同平台表现不同
对于需要深度控制线程行为的场景，可能需要使用平台特定API（通过native_handle()获取底层句柄）。但这样做会牺牲代码的可移植性。
10. 调试与问题排查
多线程程序调试是出了名的困难。以下是一些实用技巧：
- 线程命名：给线程设置描述性名称（平台特定方法）便于调试
- 日志记录：在关键点添加线程ID标记的日志
- 死锁检测：使用工具如Valgrind的Helgrind、ThreadSanitizer
- 性能分析：使用perf、VTune等工具分析线程调度和争用
一个简单的日志宏示例：
cpp复制#define LOG(msg) \
std::cout << std::this_thread::get_id() << ": " << msg << std::endl
void worker() {
LOG("Starting work");
// ...
LOG("Work completed");
}
在实际项目中，考虑使用更成熟的日志库如spdlog，它们通常内置了线程安全支持和线程ID记录功能。
11. 从线程到更高级抽象
虽然直接使用std::thread是学习并发编程的基础，但在实际项目中，通常会使用更高级的抽象：
- std::async：基于任务的异步执行
- 线程池：复用线程减少创建开销
- 并行算法：C++17引入的并行STL
- 协程：C++20引入的轻量级并发机制
理解线程基础是掌握这些高级概念的前提。在后续的学习中，我们会逐步探讨这些更高级的主题。