各位朋友们，大家好！今天咱们来聊聊一个既熟悉又可能有点陌生的家伙——C++线程，以及它背后的操作系统线程。别害怕，今天咱们不用那些枯燥的教科书语言，争取用最接地气的方式，把它们之间的关系扒个底朝天。
线程：一个CPU上的多面手
首先，想象一下CPU是个超级大厨，它一次只能炒一道菜（执行一个指令）。但是，如果只有一个任务，那大厨岂不是很浪费？所以，我们希望大厨能同时处理多个任务，比如一边炒菜，一边煲汤，一边切菜。
这时候，线程就登场了。线程就像是大厨手下的帮厨，每个帮厨负责一道菜（一个任务）。这样，大厨（CPU）就可以在不同的帮厨（线程）之间切换，给人一种“同时”处理多个任务的错觉。
这就是所谓的“并发”。注意，这里是“并发”，不是“并行”。并发是指任务看起来像是同时进行，但实际上CPU是在不同任务之间快速切换。而并行是指任务真正地同时进行，需要多个CPU核心。
操作系统线程：线程的幕后老板
现在，问题来了：这些帮厨（线程）是谁招来的？谁给他们分配任务？答案是：操作系统。
操作系统内核负责管理所有的资源，包括CPU时间。它会创建、调度和销毁线程。这些由操作系统内核管理的线程，我们称之为“内核线程”或“操作系统线程”。
操作系统线程是真正占用CPU资源的单位。也就是说，CPU时间片是分配给操作系统线程的。
C++ std::thread：线程的包装工
C++11 引入了 std::thread 类，它提供了一种在 C++ 程序中创建和管理线程的标准方式。但是，std::thread 并不是真正的线程，它只是操作系统线程的一个包装器。
可以把 std::thread 看作是一个“线程句柄”，通过这个句柄，我们可以控制和管理底层的操作系统线程。
std::thread 与 操作系统线程的映射关系
那么，std::thread 到底是如何与操作系统线程建立联系的呢？
当创建一个 std::thread 对象时，std::thread 会调用操作系统提供的线程创建函数（例如，Windows 上的 CreateThread，POSIX 上的 pthread_create）来创建一个新的操作系统线程。然后，std::thread 对象会保存这个操作系统线程的 ID，以便后续对该线程进行操作。
简单来说，std::thread 就像是操作系统线程的“遥控器”，通过这个遥控器，我们可以启动、暂停、恢复和停止操作系统线程。
下面用代码来说明：
#include <iostream>
#include <thread>
#include <chrono>
void task(int id) {
std::cout << "线程 " << id << " 开始执行" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
std::cout << "线程 " << id << " 执行完毕" << std::endl;
}
int main() {
std::thread t1(task, 1); // 创建线程 t1，执行 task(1)
std::thread t2(task, 2); // 创建线程 t2，执行 task(2)
std::cout << "主线程继续执行" << std::endl;
t1.join(); // 等待线程 t1 执行完毕
t2.join(); // 等待线程 t2 执行完毕
std::cout << "所有线程执行完毕" << std::endl;
return 0;
}在这段代码中，std::thread t1(task, 1) 和 std::thread t2(task, 2) 分别创建了两个 std::thread 对象。这两个对象在创建时，都会调用操作系统提供的线程创建函数，创建两个新的操作系统线程。这两个操作系统线程会分别执行 task(1) 和 task(2) 函数。
t1.join() 和 t2.join() 用于等待线程 t1 和 t2 执行完毕。join() 函数会阻塞当前线程（主线程），直到对应的操作系统线程执行完毕。
不同的操作系统，不同的实现
不同的操作系统，实现线程的方式可能略有不同。例如：
- Windows: 使用
CreateThread函数创建线程。std::thread内部会调用CreateThread。 - Linux/macOS: 使用
pthread_create函数创建线程。std::thread内部会调用pthread_create。
但是，无论使用哪种方式，std::thread 的作用都是一样的：提供一个跨平台的线程管理接口，隐藏底层的操作系统细节。
线程模型：一对一，多对一，多对多
线程模型描述了用户级线程（如 C++ std::thread）与内核级线程（操作系统线程）之间的关系。常见的线程模型有三种：
- 一对一模型: 每个用户级线程都对应一个内核级线程。这是
std::thread最常见的实现方式。 - 多对一模型: 多个用户级线程映射到一个内核级线程。这种模型效率较高，但如果一个用户级线程阻塞，整个进程都会阻塞。
- 多对多模型: 多个用户级线程映射到多个内核级线程。这种模型结合了前两种模型的优点，但实现起来比较复杂。
| 线程模型 | 描述 | 优点 | 缺点 |
|---|---|---|---|
| 一对一 | 每个用户级线程对应一个内核级线程。 | 真正的并行执行，一个线程阻塞不会影响其他线程。 | 创建和管理线程的开销较大，线程数量受操作系统限制。 |
| 多对一 | 多个用户级线程映射到一个内核级线程。 | 创建和管理线程的开销较小，线程数量不受操作系统限制。 | 无法实现真正的并行执行，一个线程阻塞会导致整个进程阻塞。 |
| 多对多 | 多个用户级线程映射到多个内核级线程。 | 兼顾了并行性和效率，一个线程阻塞不会影响其他线程，线程数量不受操作系统限制。 | 实现起来比较复杂，需要更复杂的调度算法。 |
std::thread 的常用操作
除了创建和等待线程之外，std::thread 还提供了一些其他的常用操作：
joinable(): 判断std::thread对象是否关联一个正在运行的线程。如果std::thread对象已经join()或detach()，则joinable()返回false。detach(): 将std::thread对象与底层的操作系统线程分离。分离后，操作系统线程会继续运行，但std::thread对象不再控制该线程。分离后的线程会在其执行完毕后自动释放资源。get_id(): 获取std::thread对象的线程 ID。线程 ID 是一个std::thread::id类型的值，可以用于唯一标识一个线程。hardware_concurrency(): 获取当前系统可以并发执行的线程数量。这通常等于 CPU 的核心数。
线程同步：避免混乱
当多个线程访问共享资源时，可能会出现竞争条件，导致程序出现错误。为了避免这种情况，我们需要使用线程同步机制。
常见的线程同步机制包括：
- 互斥锁 (Mutex): 用于保护共享资源，确保同一时间只有一个线程可以访问该资源。
- 条件变量 (Condition Variable): 用于线程之间的通信。一个线程可以等待某个条件成立，另一个线程可以在条件成立时通知等待的线程。
- 信号量 (Semaphore): 用于控制对共享资源的访问数量。
- 原子操作 (Atomic Operations): 用于对单个变量进行原子操作，避免竞争条件。
下面是一个使用互斥锁的例子：
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 互斥锁
int counter = 0;
void increment() {
for (int i = 0; i < 100000; ++i) {
std::lock_guard<std::mutex> lock(mtx); // 自动加锁和解锁
counter++;
}
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter = " << counter << std::endl; // 结果应该接近 200000
return 0;
}在这个例子中，mtx 是一个互斥锁，用于保护 counter 变量。std::lock_guard<std::mutex> lock(mtx) 会在构造时自动加锁，在析构时自动解锁，确保同一时间只有一个线程可以访问 counter 变量。
总结
C++ std::thread 是操作系统线程的一个包装器，它提供了一个跨平台的线程管理接口。std::thread 对象在创建时，会调用操作系统提供的线程创建函数创建一个新的操作系统线程。通过 std::thread 对象，我们可以控制和管理底层的操作系统线程。
掌握 std::thread 与操作系统线程之间的关系，可以帮助我们更好地理解多线程编程，编写出更高效、更稳定的程序。
希望今天的讲解对大家有所帮助！ 记住，线程编程很强大，但也需要谨慎使用，避免出现死锁和其他并发问题。 多实践，多思考，你也能成为线程编程的高手！