C++ 11是如何封装Thread库的？
在 C++11 标准中，引入了一个全新的 `` 头文件，它提供了强大的标准库支持来创建和管理线程。这标志着 C++ 在并发编程领域向前迈进了一大步，使得编写多线程程序不再依赖于平台特定的 API（如 POSIX Threads 或 Windows Threads）。
C++11 的 `` 库通过以下几个核心概念和类来封装线程功能：
1. `std::thread` 类
`std::thread` 是 C++11 中表示一个独立执行线程的核心类。它提供了创建、启动、等待和管理线程的基本功能。
如何创建和启动线程？
`std::thread` 的构造函数接收一个可调用对象（callable object）作为第一个参数，以及该可调用对象所需的参数。可调用对象可以是：
函数指针 (Function Pointer):
```c++
include
include
void print_message(const std::string& message) {
std::cout << "Message: " << message << std::endl;
}
int main() {
std::thread t1(print_message, "Hello from thread!"); // 创建并启动线程
// ...
}
```
当 `std::thread` 对象被创建时，它会立即启动与构造函数中提供的可调用对象关联的新线程。
函数对象 (Function Object / Functor):
```c++
include
include
include
class Greeter {
public:
void operator()(const std::string& name) {
std::cout << "Hello, " << name << "!" << std::endl;
}
};
int main() {
Greeter greeter_obj;
std::thread t2(greeter_obj, "Alice"); // 创建并启动线程
// ...
}
```
Lambda 表达式 (Lambda Expression): 这是 C++11 引入的特性，非常方便用于创建线程。
```c++
include
include
include
int main() {
std::string message = "Lambda message";
std::thread t3([&message]() { // [&message] 捕获 message 变量
std::cout << "From lambda: " << message << std::endl;
});
// ...
}
```
线程的生命周期管理:
`join()`: `join()` 方法用于等待一个线程完成执行。调用 `join()` 的线程会阻塞，直到被 `join()` 的线程结束。如果一个 `std::thread` 对象在析构前没有被 `join()` 或 `detach()`，程序将终止（调用 `std::terminate()`）。
```c++
int main() {
std::thread t1(print_message, "Hello from thread!");
// ... do other work ...
t1.join(); // 等待 t1 完成
std::cout << "Thread t1 has finished." << std::endl;
}
```
`detach()`: `detach()` 方法将线程与 `std::thread` 对象分离。一旦线程被分离，`std::thread` 对象将不再代表该线程，并且该线程将继续独立运行，直到完成。一旦分离，就无法再 `join()` 该线程。 分离的线程会在其执行完成后自动释放资源。
```c++
int main() {
std::thread t1(print_message, "Detached thread!");
t1.detach(); // 分离线程，主线程继续执行，不再关心 t1 的结束
std::cout << "Thread t1 detached." << std::endl;
// 在这里不能调用 t1.join();
// 主线程可能会比 t1 先结束，导致 t1 运行在后台，或者如果主线程结束且 t1 还在运行，
// 它的行为取决于操作系统和如何处理后台线程。
// 通常不推荐分离线程，除非非常确定其生命周期管理。
}
```
`joinable()`: 返回一个布尔值，指示该 `std::thread` 对象是否代表一个活动的、可被 `join()` 或 `detach()` 的线程。
```c++
std::thread t1(print_message, "Checkable thread");
if (t1.joinable()) {
t1.join();
}
```
`get_id()`: 返回当前线程的唯一标识符。
```c++
std::thread t1(print_message, "Thread with ID");
std::cout << "Thread ID: " << t1.get_id() << std::endl;
```
`std::this_thread::get_id()`: 用于获取当前执行线程的ID。
```c++
void print_current_id() {
std::cout << "Current thread ID: " << std::this_thread::get_id() << std::endl;
}
int main() {
std::thread t1(print_current_id);
print_current_id(); // 在主线程中打印
t1.join();
}
```
2. 线程间同步和通信 (Synchronization and Communication)
C++11 提供了一套强大的工具来解决并发编程中的常见问题，如数据竞争和线程间通信。
互斥量 (`std::mutex`) 和锁 (`std::lock_guard`, `std::unique_lock`):
互斥量是用于保护共享数据不被多个线程同时访问的关键机制。当一个线程需要访问共享资源时，它会尝试锁定互斥量。如果互斥量已被其他线程锁定，则当前线程将阻塞，直到互斥量被释放。
`std::mutex`: 提供基本的 `lock()` 和 `unlock()` 方法。
```c++
include
include
include
int shared_counter = 0;
std::mutex mtx; // 互斥量
void increment() {
mtx.lock(); // 尝试锁定互斥量
shared_counter++; // 访问共享资源
std::cout << "Counter: " << shared_counter << std::endl;
mtx.unlock(); // 解锁互斥量
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
return 0;
}
```
手动 lock/unlock 的问题: 如果在持有锁期间发生异常，`unlock()` 可能不会被调用，导致死锁。
`std::lock_guard`: RAII（Resource Acquisition Is Initialization）风格的锁。在构造时锁定互斥量，在析构时自动解锁互斥量。这是推荐使用的锁类型，因为它能确保互斥量总是被正确解锁，即使发生异常。
```c++
void increment_safe() {
std::lock_guard lock(mtx); // 在构造时锁定 mtx
shared_counter++;
std::cout << "Counter (safe): " << shared_counter << std::endl;
} // lock_guard 在这里被销毁，自动解锁 mtx
```
`std::unique_lock`: 比 `std::lock_guard` 更灵活。它也支持 RAII，但允许更精细的控制，例如：
在需要时手动 `lock()` 和 `unlock()`。
在特定条件下延迟锁定。
将锁的所有权转移给另一个 `std::unique_lock` 对象。
与条件变量一起使用。
```c++
void increment_flexible() {
std::unique_lock lock(mtx); // 构造时锁定
shared_counter++;
std::cout << "Counter (flexible): " << shared_counter << std::endl;
// lock.unlock(); // 可以手动解锁
// ...
// lock.lock(); // 之后可以再次锁定
}
```
条件变量 (`std::condition_variable`):
条件变量允许线程在某个特定条件满足前睡眠（等待），并且允许其他线程在条件满足时通知（唤醒）等待的线程。它们通常与互斥量一起使用。
工作流程:
1. 一个线程想要等待某个条件，它会锁定一个互斥量。
2. 然后它检查条件是否满足。
3. 如果条件不满足，它调用条件变量的 `wait()` 方法。`wait()` 会原子地解锁互斥量并让线程进入睡眠状态。
4. 当另一个线程修改了状态，使得条件可能满足时，它会锁定同一个互斥量，修改状态，然后调用条件变量的 `notify_one()` (唤醒一个等待线程) 或 `notify_all()` (唤醒所有等待线程)。
5. 被唤醒的线程会重新尝试锁定互斥量，然后再次检查条件。如果条件满足，它就继续执行；否则，它会再次调用 `wait()` 进入睡眠。
示例：生产者消费者模型
```c++
include
include
include
include
include
include
std::queue data_queue;
std::mutex mtx;
std::condition_variable cv;
bool finished = false;
void producer() {
for (int i = 0; i < 10; ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟工作
{
std::lock_guard lock(mtx);
data_queue.push(i);
std::cout << "Produced: " << i << std::endl;
}
cv.notify_one(); // 通知一个等待的消费者
}
{ // 告知消费者生产者已完成
std::lock_guard lock(mtx);
finished = true;
}
cv.notify_all(); // 唤醒所有消费者，以便它们检查 finished 标志
}
void consumer() {
while (true) {
int data;
{
std::unique_lock lock(mtx);
// wait() 接收一个 lambda 作为谓词，如果谓词返回 false，则线程会睡眠。
// 当被通知时，会重新检查谓词。这可以避免虚假唤醒 (spurious wakeups)。
cv.wait(lock, []{ return !data_queue.empty() || finished; });
if (data_queue.empty() && finished) {
break; // 所有数据都已消费，且生产者已结束
}
data = data_queue.front();
data_queue.pop();
std::cout << "Consumed: " << data << std::endl;
} // lock 被释放
// 可以在这里处理消费到的数据，避免持有锁的时间过长
}
}
int main() {
std::thread prod_thread(producer);
std::thread cons_thread1(consumer);
std::thread cons_thread2(consumer);
prod_thread.join();
cons_thread1.join();
cons_thread2.join();
return 0;
}
```
`cv.wait(lock, predicate)` 的重要性: `wait()` 函数在被唤醒后，会重新锁定互斥量，并检查提供的谓词（lambda 函数）。如果谓词返回 `false`，线程会再次进入睡眠状态。这是为了处理“虚假唤醒”（spurious wakeups），即线程可能在没有 `notify_one` 或 `notify_all` 调用的情况下被唤醒。通过谓词，可以确保线程只有在真正满足条件时才继续执行。
`std::atomic`:
`std::atomic` 是 C++11 引入的用于实现原子操作的模板。原子操作是指不可分割的操作，即从开始到结束不会被任何其他线程中断。这对于简单的计数器、标志位等操作非常有用，可以避免使用互斥量带来的性能开销。
示例：原子计数器
```c++
include
include
include
std::atomic atomic_counter(0); // 原子整数计数器
void increment_atomic() {
atomic_counter++; // 原子操作，无需互斥量
}
int main() {
std::thread t1(increment_atomic);
std::thread t2(increment_atomic);
t1.join();
t2.join();
std::cout << "Atomic counter: " << atomic_counter << std::endl; // 总是正确的
return 0;
}
```
`std::atomic` 支持多种类型，并且提供了 `load()` (读取), `store()` (写入), `exchange()` (读写交换), `compare_exchange_weak()` / `compare_exchange_strong()` (比较并交换) 等操作。这些操作可以指定内存顺序（memory order），以控制线程之间可见的顺序。
3. 线程局部存储 (`thread_local`)
`thread_local` 关键字允许为变量创建线程私有的副本。每个线程访问的 `thread_local` 变量都是独立于其他线程的。这对于在多线程环境中避免共享数据和保护数据隐私非常有用。
示例:
```c++
include
include
thread_local int thread_local_var = 0;
void print_thread_local() {
thread_local_var++;
std::cout << "Thread ID: " << std::this_thread::get_id()
<< ", thread_local_var: " << thread_local_var << std::endl;
}
int main() {
std::thread t1(print_thread_local);
std::thread t2(print_thread_local);
std::thread t3(print_thread_local);
t1.join();
t2.join();
t3.join();
// 在主线程中访问，也是独立的副本
thread_local_var++;
std::cout << "Main thread ID: " << std::this_thread::get_id()
<< ", thread_local_var: " << thread_local_var << std::endl;
return 0;
}
```
输出会显示每个线程的 `thread_local_var` 都是从 1 开始累加的，并且主线程的 `thread_local_var` 也是独立的。
4. 其他并发工具
`std::call_once` 和 `std::once_flag`: 用于确保某个操作在多个线程中只执行一次，通常用于延迟初始化。
```c++
include
include
include
std::once_flag init_flag;
void initialize_resource() {
std::cout << "Resource initialized." << std::endl;
}
void do_work() {
std::call_once(init_flag, initialize_resource); // 确保 initialize_resource 只被调用一次
std::cout << "Thread " << std::this_thread::get_id() << " is working." << std::endl;
}
int main() {
std::thread t1(do_work);
std::thread t2(do_work);
std::thread t3(do_work);
t1.join();
t2.join();
t3.join();
return 0;
}
```
`std::packaged_task` 和 `std::future` / `std::async`: 用于异步执行任务并获取结果。
`std::packaged_task` 将一个可调用对象包装起来，使其可以被异步执行，并将结果存储在一个 `std::future` 中。
`std::future` 提供了一种访问异步操作结果的方法，可以在结果可用时获取。
`std::async` 是一个更高级的函数，可以方便地启动一个异步任务，并返回一个 `std::future` 对象。
```c++
include
include
include
include
int calculate_sum(int a, int b) {
std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时操作
return a + b;
}
int main() {
// 使用 std::async 直接启动异步任务
std::future result_future = std::async(std::launch::async, calculate_sum, 5, 10);
std::cout << "Doing other work while async task is running..." << std::endl;
// 获取异步任务的结果，如果任务未完成，get() 会阻塞直到结果可用
int sum = result_future.get();
std::cout << "Async task result: " << sum << std::endl;
return 0;
}
```
`std::async` 还可以指定启动策略：
`std::launch::async`: 确保任务在新线程中执行。
`std::launch::deferred`: 延迟执行任务，直到 `get()` 或 `wait()` 被调用，此时任务将在调用线程中执行。
默认情况下，`std::async` 可以根据系统负载选择策略。
C++11 `` 库的优势
标准统一: 提供了跨平台的一致性 API，摆脱了对 POSIX 或 Windows 特定 API 的依赖。
易用性: `std::thread` 的构造函数和 RAII 风格的锁（如 `std::lock_guard`）使得创建和管理线程更加简单和安全。
安全性: 内置的同步原语（互斥量、条件变量、原子操作）帮助开发者更安全地处理并发问题。
现代 C++ 特性集成: 很好地结合了 Lambda 表达式、`std::function` 等现代 C++ 特性，提高了代码的可读性和灵活性。
C++11 `` 库的局限性（以及后续 C++ 标准的改进）
虽然 C++11 的 `` 库是一个重大的进步，但它也有一些局限性，后续的 C++ 标准（如 C++14, C++17, C++20）在并发领域进行了进一步的改进和扩展，例如：
C++17 的 `std::scoped_lock` 和 `std::lock`: 提供了更方便的机制来锁定多个互斥量，避免死锁。
C++20 的 `std::jthread`: 自动 join 的线程，简化了线程的生命周期管理。
更高级的同步原语: 如 `std::counting_semaphore`, `std::latch`, `std::barrier` 等。
总而言之，C++11 的 `` 库通过提供 `std::thread` 类以及一系列同步工具（互斥量、条件变量、原子类型），极大地简化了 C++ 中的多线程编程，并引入了标准化的、安全的方式来处理并发任务。
C++11 的 `
1. `std::thread` 类
`std::thread` 是 C++11 中表示一个独立执行线程的核心类。它提供了创建、启动、等待和管理线程的基本功能。
如何创建和启动线程？
`std::thread` 的构造函数接收一个可调用对象（callable object）作为第一个参数，以及该可调用对象所需的参数。可调用对象可以是：
函数指针 (Function Pointer):
```c++
include
include
void print_message(const std::string& message) {
std::cout << "Message: " << message << std::endl;
}
int main() {
std::thread t1(print_message, "Hello from thread!"); // 创建并启动线程
// ...
}
```
当 `std::thread` 对象被创建时，它会立即启动与构造函数中提供的可调用对象关联的新线程。
函数对象 (Function Object / Functor):
```c++
include
include
include
class Greeter {
public:
void operator()(const std::string& name) {
std::cout << "Hello, " << name << "!" << std::endl;
}
};
int main() {
Greeter greeter_obj;
std::thread t2(greeter_obj, "Alice"); // 创建并启动线程
// ...
}
```
Lambda 表达式 (Lambda Expression): 这是 C++11 引入的特性，非常方便用于创建线程。
```c++
include
include
include
int main() {
std::string message = "Lambda message";
std::thread t3([&message]() { // [&message] 捕获 message 变量
std::cout << "From lambda: " << message << std::endl;
});
// ...
}
```
线程的生命周期管理:
`join()`: `join()` 方法用于等待一个线程完成执行。调用 `join()` 的线程会阻塞，直到被 `join()` 的线程结束。如果一个 `std::thread` 对象在析构前没有被 `join()` 或 `detach()`，程序将终止（调用 `std::terminate()`）。
```c++
int main() {
std::thread t1(print_message, "Hello from thread!");
// ... do other work ...
t1.join(); // 等待 t1 完成
std::cout << "Thread t1 has finished." << std::endl;
}
```
`detach()`: `detach()` 方法将线程与 `std::thread` 对象分离。一旦线程被分离，`std::thread` 对象将不再代表该线程，并且该线程将继续独立运行，直到完成。一旦分离，就无法再 `join()` 该线程。 分离的线程会在其执行完成后自动释放资源。
```c++
int main() {
std::thread t1(print_message, "Detached thread!");
t1.detach(); // 分离线程，主线程继续执行，不再关心 t1 的结束
std::cout << "Thread t1 detached." << std::endl;
// 在这里不能调用 t1.join();
// 主线程可能会比 t1 先结束，导致 t1 运行在后台，或者如果主线程结束且 t1 还在运行，
// 它的行为取决于操作系统和如何处理后台线程。
// 通常不推荐分离线程，除非非常确定其生命周期管理。
}
```
`joinable()`: 返回一个布尔值，指示该 `std::thread` 对象是否代表一个活动的、可被 `join()` 或 `detach()` 的线程。
```c++
std::thread t1(print_message, "Checkable thread");
if (t1.joinable()) {
t1.join();
}
```
`get_id()`: 返回当前线程的唯一标识符。
```c++
std::thread t1(print_message, "Thread with ID");
std::cout << "Thread ID: " << t1.get_id() << std::endl;
```
`std::this_thread::get_id()`: 用于获取当前执行线程的ID。
```c++
void print_current_id() {
std::cout << "Current thread ID: " << std::this_thread::get_id() << std::endl;
}
int main() {
std::thread t1(print_current_id);
print_current_id(); // 在主线程中打印
t1.join();
}
```
2. 线程间同步和通信 (Synchronization and Communication)
C++11 提供了一套强大的工具来解决并发编程中的常见问题，如数据竞争和线程间通信。
互斥量 (`std::mutex`) 和锁 (`std::lock_guard`, `std::unique_lock`):
互斥量是用于保护共享数据不被多个线程同时访问的关键机制。当一个线程需要访问共享资源时，它会尝试锁定互斥量。如果互斥量已被其他线程锁定，则当前线程将阻塞，直到互斥量被释放。
`std::mutex`: 提供基本的 `lock()` 和 `unlock()` 方法。
```c++
include
include
include
int shared_counter = 0;
std::mutex mtx; // 互斥量
void increment() {
mtx.lock(); // 尝试锁定互斥量
shared_counter++; // 访问共享资源
std::cout << "Counter: " << shared_counter << std::endl;
mtx.unlock(); // 解锁互斥量
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
return 0;
}
```
手动 lock/unlock 的问题: 如果在持有锁期间发生异常，`unlock()` 可能不会被调用，导致死锁。
`std::lock_guard
```c++
void increment_safe() {
std::lock_guard
shared_counter++;
std::cout << "Counter (safe): " << shared_counter << std::endl;
} // lock_guard 在这里被销毁，自动解锁 mtx
```
`std::unique_lock
在需要时手动 `lock()` 和 `unlock()`。
在特定条件下延迟锁定。
将锁的所有权转移给另一个 `std::unique_lock` 对象。
与条件变量一起使用。
```c++
void increment_flexible() {
std::unique_lock
shared_counter++;
std::cout << "Counter (flexible): " << shared_counter << std::endl;
// lock.unlock(); // 可以手动解锁
// ...
// lock.lock(); // 之后可以再次锁定
}
```
条件变量 (`std::condition_variable`):
条件变量允许线程在某个特定条件满足前睡眠（等待），并且允许其他线程在条件满足时通知（唤醒）等待的线程。它们通常与互斥量一起使用。
工作流程:
1. 一个线程想要等待某个条件，它会锁定一个互斥量。
2. 然后它检查条件是否满足。
3. 如果条件不满足，它调用条件变量的 `wait()` 方法。`wait()` 会原子地解锁互斥量并让线程进入睡眠状态。
4. 当另一个线程修改了状态，使得条件可能满足时，它会锁定同一个互斥量，修改状态，然后调用条件变量的 `notify_one()` (唤醒一个等待线程) 或 `notify_all()` (唤醒所有等待线程)。
5. 被唤醒的线程会重新尝试锁定互斥量，然后再次检查条件。如果条件满足，它就继续执行；否则，它会再次调用 `wait()` 进入睡眠。
示例：生产者消费者模型
```c++
include
include
include
include
include
include
std::queue
std::mutex mtx;
std::condition_variable cv;
bool finished = false;
void producer() {
for (int i = 0; i < 10; ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟工作
{
std::lock_guard
data_queue.push(i);
std::cout << "Produced: " << i << std::endl;
}
cv.notify_one(); // 通知一个等待的消费者
}
{ // 告知消费者生产者已完成
std::lock_guard
finished = true;
}
cv.notify_all(); // 唤醒所有消费者，以便它们检查 finished 标志
}
void consumer() {
while (true) {
int data;
{
std::unique_lock
// wait() 接收一个 lambda 作为谓词，如果谓词返回 false，则线程会睡眠。
// 当被通知时，会重新检查谓词。这可以避免虚假唤醒 (spurious wakeups)。
cv.wait(lock, []{ return !data_queue.empty() || finished; });
if (data_queue.empty() && finished) {
break; // 所有数据都已消费，且生产者已结束
}
data = data_queue.front();
data_queue.pop();
std::cout << "Consumed: " << data << std::endl;
} // lock 被释放
// 可以在这里处理消费到的数据，避免持有锁的时间过长
}
}
int main() {
std::thread prod_thread(producer);
std::thread cons_thread1(consumer);
std::thread cons_thread2(consumer);
prod_thread.join();
cons_thread1.join();
cons_thread2.join();
return 0;
}
```
`cv.wait(lock, predicate)` 的重要性: `wait()` 函数在被唤醒后，会重新锁定互斥量，并检查提供的谓词（lambda 函数）。如果谓词返回 `false`，线程会再次进入睡眠状态。这是为了处理“虚假唤醒”（spurious wakeups），即线程可能在没有 `notify_one` 或 `notify_all` 调用的情况下被唤醒。通过谓词，可以确保线程只有在真正满足条件时才继续执行。
`std::atomic`:
`std::atomic` 是 C++11 引入的用于实现原子操作的模板。原子操作是指不可分割的操作，即从开始到结束不会被任何其他线程中断。这对于简单的计数器、标志位等操作非常有用，可以避免使用互斥量带来的性能开销。
示例：原子计数器
```c++
include
include
include
std::atomic
void increment_atomic() {
atomic_counter++; // 原子操作，无需互斥量
}
int main() {
std::thread t1(increment_atomic);
std::thread t2(increment_atomic);
t1.join();
t2.join();
std::cout << "Atomic counter: " << atomic_counter << std::endl; // 总是正确的
return 0;
}
```
`std::atomic` 支持多种类型，并且提供了 `load()` (读取), `store()` (写入), `exchange()` (读写交换), `compare_exchange_weak()` / `compare_exchange_strong()` (比较并交换) 等操作。这些操作可以指定内存顺序（memory order），以控制线程之间可见的顺序。
3. 线程局部存储 (`thread_local`)
`thread_local` 关键字允许为变量创建线程私有的副本。每个线程访问的 `thread_local` 变量都是独立于其他线程的。这对于在多线程环境中避免共享数据和保护数据隐私非常有用。
示例:
```c++
include
include
thread_local int thread_local_var = 0;
void print_thread_local() {
thread_local_var++;
std::cout << "Thread ID: " << std::this_thread::get_id()
<< ", thread_local_var: " << thread_local_var << std::endl;
}
int main() {
std::thread t1(print_thread_local);
std::thread t2(print_thread_local);
std::thread t3(print_thread_local);
t1.join();
t2.join();
t3.join();
// 在主线程中访问，也是独立的副本
thread_local_var++;
std::cout << "Main thread ID: " << std::this_thread::get_id()
<< ", thread_local_var: " << thread_local_var << std::endl;
return 0;
}
```
输出会显示每个线程的 `thread_local_var` 都是从 1 开始累加的，并且主线程的 `thread_local_var` 也是独立的。
4. 其他并发工具
`std::call_once` 和 `std::once_flag`: 用于确保某个操作在多个线程中只执行一次，通常用于延迟初始化。
```c++
include
include
include
std::once_flag init_flag;
void initialize_resource() {
std::cout << "Resource initialized." << std::endl;
}
void do_work() {
std::call_once(init_flag, initialize_resource); // 确保 initialize_resource 只被调用一次
std::cout << "Thread " << std::this_thread::get_id() << " is working." << std::endl;
}
int main() {
std::thread t1(do_work);
std::thread t2(do_work);
std::thread t3(do_work);
t1.join();
t2.join();
t3.join();
return 0;
}
```
`std::packaged_task` 和 `std::future` / `std::async`: 用于异步执行任务并获取结果。
`std::packaged_task` 将一个可调用对象包装起来，使其可以被异步执行，并将结果存储在一个 `std::future` 中。
`std::future` 提供了一种访问异步操作结果的方法，可以在结果可用时获取。
`std::async` 是一个更高级的函数，可以方便地启动一个异步任务，并返回一个 `std::future` 对象。
```c++
include
include
include
include
int calculate_sum(int a, int b) {
std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时操作
return a + b;
}
int main() {
// 使用 std::async 直接启动异步任务
std::future
std::cout << "Doing other work while async task is running..." << std::endl;
// 获取异步任务的结果，如果任务未完成，get() 会阻塞直到结果可用
int sum = result_future.get();
std::cout << "Async task result: " << sum << std::endl;
return 0;
}
```
`std::async` 还可以指定启动策略：
`std::launch::async`: 确保任务在新线程中执行。
`std::launch::deferred`: 延迟执行任务，直到 `get()` 或 `wait()` 被调用，此时任务将在调用线程中执行。
默认情况下，`std::async` 可以根据系统负载选择策略。
C++11 `
标准统一: 提供了跨平台的一致性 API，摆脱了对 POSIX 或 Windows 特定 API 的依赖。
易用性: `std::thread` 的构造函数和 RAII 风格的锁（如 `std::lock_guard`）使得创建和管理线程更加简单和安全。
安全性: 内置的同步原语（互斥量、条件变量、原子操作）帮助开发者更安全地处理并发问题。
现代 C++ 特性集成: 很好地结合了 Lambda 表达式、`std::function` 等现代 C++ 特性，提高了代码的可读性和灵活性。
C++11 `
虽然 C++11 的 `
C++17 的 `std::scoped_lock` 和 `std::lock`: 提供了更方便的机制来锁定多个互斥量，避免死锁。
C++20 的 `std::jthread`: 自动 join 的线程，简化了线程的生命周期管理。
更高级的同步原语: 如 `std::counting_semaphore`, `std::latch`, `std::barrier` 等。
总而言之，C++11 的 `
网友意见
绝大多数OS的thread入口函数大致是这样的：
void_or_error_code entry_point(void *arbitrary_data); 而std::thread的构造函数长这样：
template< class Function, class... Args > explicit thread( Function&& f, Args&&... args ); 为了填平两者之间的差异，我们要做的就是把f和args统统打包在一起做成一个void *，然后用一个预定义的plain C function作为entry point，接收这个void *，解开其中的f和args，然后调用。
和某些回答的说法不同，OS thread API不能直接触碰function template，因为它们大都长这样（略去不相关的参数）：
error_code create_thread((void_or_error_code(*entry)(void *), void *data); 不用折腾了，你想破头也没办法让这个API直接调用一个function template或者一个lambda，你只能给它提供一个plain function pointer。用std::function<void_or_error()>绕圈子是个办法，但到最后你还是需要把f和args打包在一起，然后再用一个包装函数拆包调用f(args...)，然后再把这个函数包装在std::function里，我觉得反倒更麻烦了。
下面一步一步细说:
1、打包f和args成一个void *
当然我们不能真得把f和args直接变成一个void *，至少尺寸肯定不合适，所以我们需要一个数据结构来保存f和arg。另外，我们说过thread entry point必需是一个plain function，所以template戏法对于entry point来说是不能用的，为了让我们的entry point可以使用这些数据，我们需要一个concrete type而不是template。
不得不承认virtual function有时候还是有用的。让我们定义一个基类：
struct thread_data_base { virtual ~thread_data_base(){} virtual void run()=0; }; 这个基类给我们提供了一个统一的入口，可以调用实际用户提供的f和args。
2、接下来我们定义一个template，以适配不同类型的f和args：
template<typename F, class... ArgTypes> class thread_data : public thread_data_base { public: thread_data(F&& f_, ArgTypes&&... args_) : fp(std::forward<F>(f_), std::forward<ArgTypes>(args_)...) {} template <std::size_t... Indices> void run2(tuple_indices<Indices...>) { invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...); } void run() { typedef typename make_tuple_indices<std::tuple_size<std::tuple<F, ArgTypes...> >::value, 1>::type index_type; run2(index_type()); } private: /// Non-copyable thread_data(const thread_data&)=delete; void operator=(const thread_data&)=delete; std::tuple<typename std::decay<F>::type, typename std::decay<ArgTypes>::type...> fp; }; 在这个template里有一个data member，它是一个tuple，用于保存f和args，这样我们就可以通过将void *data cast成thread_data_base *，然后调用其中的虚函数run来实际调用f(args...)，里面的invoke和tuple_indices等下再说。
3、然后我们就可以用一个简单的函数把任意的f和args包装成一个thread_data_base *：
template<typename F, class... ArgTypes> inline thread_data_base *make_thread_data(F&& f, ArgTypes&&... args) { return new thread_data<typename std::remove_reference<F>::type, ArgTypes...>(std::forward<F>(f), std::forward<ArgTypes>(args)...); } 4、thread entry point变得很简单，这样就行了：
void_or_error_code thread_entry(void *data) { std::unique_ptr<thread_data_base> p((thread_data_base *)data); p->run(); // return result of p->run() if error code is required } 异常处理等细节略去。
注意：下节含有大量C++黑魔法，可能会引起阅读者不适，请谨慎前行
5、下面看看invoke，或者说如何通过一个f和args组成的tuple调用f(args...)
简单说，对于一个tuple<F, T1, T2, T3> tp(f, a1, a2, a3)，如果你想调用f(a1, a2, a3)，你需要：
tp.get<0>()(tp.get<1>(), tp.get<2>(), tp.get<3>()); forward和decay神马的略去不提。
注意这里的1、2、3必须是编译期常数，否则你是没法拿来当template参数的，也就是说，为了调用f(args...)，我们必需生成一个编译期的数列，这各编译期的数列就是前面提到的tuple_indices。
有了这个数列，假如它叫Indices，我们就可以这样调用：
tp.get<0>()(tp.get<Indices>()...); make_tuple_indices就是用来生成Indices的。
为了生成数列[Sp, Ep)，我们要做的就是从Sp开始，递归的在已有数列后面加一项，直到满足条件(Sp==Ep)。
让我们先定义tuple_indices：
template <std::size_t...> struct tuple_indices {}; 这个类不需要任何成员，所有需要的信息，也就是整个数列，都是template参数，是类型的一部分。
为了让代码清楚一点，我们再绕个圈子：
template <std::size_t Sp, class IntTuple, std::size_t Ep> struct make_indices_imp; 之所以要绕这个圈子，是因为我们的make_tuple_indices应该长这样：
template <std::size_t Ep, std::size_t Sp> struct make_tuple_indices {...}; 但在生成这个数列的过程中，为了方便，我们想把数列当前项直接放在参数列表里，要不然还需要在内部找到数列的最后一项，太烦。
这个make_tuple_indices_imp完工后是这个样子的：
template <std::size_t Sp, class IntTuple, std::size_t Ep> struct make_indices_imp; template <std::size_t Sp, std::size_t... Indices, std::size_t Ep> struct make_indices_imp<Sp, tuple_indices<Indices...>, Ep> { typedef typename make_indices_imp<Sp+1, tuple_indices<Indices..., Sp>, Ep>::type type; }; template <std::size_t Ep, std::size_t... Indices> struct make_indices_imp<Ep, tuple_indices<Indices...>, Ep> { typedef tuple_indices<Indices...> type; }; 可以看到有三个版本，第一个是泛化形式，第二个是递归中间结果，第三个是递归终止条件(Sp==Ep)
然后我们就可以把make_tuple_indices写出来了：
template <std::size_t Ep, std::size_t Sp=0> struct make_tuple_indices { typedef typename make_indices_imp<Sp, tuple_indices<>, Ep>::type type; }; 注意为了方便起见，Ep在前面，Sp在后面，因为缺省参数必须在最后（没办法C++就是这么规定的）
invoke可以很简单，就是把所有东西都forward过去调f：
template <class Fp, class... Args> inline auto invoke(Fp&& f, Args&&... args) -> decltype(std::forward<Fp>(f)(std::forward<Args>(args)...)) { return std::forward<Fp>(f)(std::forward<Args>(args)...); } 当然，为了应付不同的callable，比如成员函数指针，或者有operator()的类，或者lambda什么的，我们可能还需要几个特化，不过这些都不重要，这里就不说了。
6、有了上面这些东西，之前的thread_data::run/run2就能运转了，它能通过make_tuple_indices和invoke解包tuple并调用f(args...)。
我们已经有了run，之所以需要再定义一个run2，是因为一条可能很多人猛一下想不起来的C++语法规定——member function template不能是虚函数。
Indices是一个template type，只能用一个template function接收，所以我们需要把run和run2拆开，run作为继承下来的虚函数做入口，run2接收Indices并用之前提到的方法调用f(args...)。
结论：C++写这种东西神烦，要是有其它选择我立马叛逃（Rust目前还不够诱惑，等等再说）
类似的话题
-
在 C++11 标准中，引入了一个全新的 `` 头文件，它提供了强大的标准库支持来创建和管理线程。这标志着 C++ 在并发编程领域向前迈进了一大步，使得编写多线程程序不再依赖于平台特定的 API（如 POSIX Threads 或 Windows Threads）。C++11 的 `` 库通过以下几............. -
好的，咱们来一起把这个问题捋一捋，证明 $a^2 + b^2 + c^2 + 2abc$ 在 $a, b, c$ 是正数且 $a+b+c=1$ 的条件下，其范围确实是在 $[11/27, 1)$ 之间。这个题目有点意思，需要用到一些数学技巧。咱们先来理解一下这个式子和条件： 条件： $a, b,.............
-
.......
-
.......
-
在C++中，表达式 `unsigned t = 2147483647 + 1 + 1;` 的求值过程，既不是UB（Undefined Behavior），也不是ID（ImplementationDefined Behavior），而是一个有明确定义的整数溢出（Integer Overflow）行为。.............
-
.......
-
在 C++11 之前，C++ 程序中表示“空指针”通常使用一个宏定义，比如 `NULL`。这个宏在 C 语言中被广泛使用，它通常被定义为整数 `0` 或者 `(void)0`。虽然在很多情况下 `NULL` 工作得很好，但它在 C++ 中引入了一些潜在的问题和歧义，尤其是在处理函数重载和模板时。NU.............
-
好的，咱们来聊聊 C++11 里怎么把单例模式玩明白。这玩意儿看着简单，但要弄得既安全又高效，还得考虑不少细节。咱们就抛开那些花里胡哨的“AI风”描述，实打实地把这事儿掰开了揉碎了说。单例模式，说白了就是保证一个类在整个程序的生命周期里，只有一个实例存在，并且提供一个全局的访问点。想象一下，你有个配.............
-
C++ 的发展确实迅猛，每一次标准更新都带来了大量的新特性。但在这快速迭代的背后，核心的编程范式、设计哲学以及对底层硬件的抽象原则，在很大程度上保持着不变。这些不变的东西，构成了 C++ 坚实的根基，使得我们可以站在巨人的肩膀上，不断学习和利用新的语言能力。让我为你详细解读一下这些“不变的东西”，尽.............
-
C++11 和 C++1y（现称为 C++14）都没有将网络功能作为核心组成部分优先加入标准库，这背后有着复杂的原因，涉及到语言设计哲学、技术实现难度、社区共识以及现有生态的考量。1. C++ 的设计哲学与标准库的定位C++ 的核心设计哲学是“零开销抽象”（zerooverhead abstract.............
-
GCC 的 C++11 正则表达式库是 C++11 标准中引入的一项重要功能，它为 C++ 开发者提供了一种标准化的、类型安全的方式来处理正则表达式。在评价它时，我们可以从多个维度进行详细的分析： 整体评价：GCC 的 C++11 正则表达式库是一个非常有用的、功能强大且符合标准的库。它填补了 C+.............
-
C++11 `auto` 关键字：优雅与效率的双重奏C++11 引入的 `auto` 关键字，对于很多 C++ 开发者来说，无疑是近年来最令人欣喜的语言特性之一。它不仅仅是语法上的一个小小的改动，更深层次地影响了我们编写 C++ 代码的方式，带来了更高的可读性和更少的繁琐。那么，究竟该如何评价这个小.............
-
来，咱们聊聊 C++11 里的那些内存顺序（Memory Order）。这东西刚听着有点玄乎，但弄明白了，你会发现它在多线程的世界里简直是个宝贝，能帮你解决不少棘手的问题。之前我刚接触的时候也觉得脑袋疼，但多看多想，再加上一些实际的例子，感觉就通透了。先说清楚，内存顺序这玩意儿，本质上是为了控制多线.............
-
Qt Creator 对 C++11 的 `auto` 类型在代码提示方面表现不佳，这确实是一个让不少开发者感到困扰的问题。这背后涉及到 Qt Creator 的代码解析机制、C++ 标准的支持程度以及一些历史遗留的考量。要理解这个问题，我们得先剖析一下 Qt Creator 的代码补全是如何工作的.............
-
好的，我们来聊聊怎么用 C 语言的 `for` 循环来计算 1 + 11 + 111 + 1111 这个特定的累加和。这实际上是一个很有趣的小问题，因为它涉及到了数字模式的生成和累加。理解问题：我们要加的是什么？首先，我们要清楚我们要计算的式子是：1 + 11 + 111 + 1111我们可以发现，.............
-
梅西和 C 罗一共拿了 11 个金球奖，说是因为他们的竞争者太弱了，这就像是说万里长城是因为没有遇到过真正的入侵者才建成的，听起来有些道理，但忽略了太多关键的东西。仔细想想，这两人能连续十年甚至更久的时间霸占最高荣誉，绝不仅仅是运气好或者对手不给力那么简单。首先，我们得承认，梅西和 C 罗本身就是那.............
-
咱们来聊聊咱国产空军的几款主力战机：歼10C、歼11和歼16。这三款飞机虽然都是多用途战斗机，但在设计理念、侧重点和具体用途上，还是有挺大区别的。歼10C：灵活的“空中多面手”，制空与对地兼顾你可以把歼10C想象成一把瑞士军刀，或者更形象地说，它更像是一款“空中全能选手”。 设计理念： 歼10C.............
-
各位朋友，大家好！今天我们来聊一个关于数学不等式的问题，而且这个问题很有意思，涉及到三个正数 a, b, c，它们之间还有一个重要的关系：abc = 1。我们的目标是证明：$$ frac{1}{sqrt{1+8a}} + frac{1}{sqrt{1+8b}} + frac{1}{sqrt{1+8c.............
-
2018年俄罗斯世界杯，B组小组赛的最后一轮，伊朗对阵葡萄牙的比赛，绝对是那届世界杯最令人血脉偾张、也最具戏剧性的一场。最终的比分定格在1:1，这个结果对双方来说，都带着一丝苦涩与不甘。先说说伊朗队，那场比赛他们几乎是抱着必胜的信念走上赛场的。要知道，在那之前，他们已经战胜了摩洛哥，逼平了西班牙，展.............
-
零跑C11补贴后15.98万起，这个价格一出来，确实在新能源SUV市场投下了一颗石子，激起了不少涟漪。咱们就来好好掰扯掰扯，这零跑C11究竟值不值这个价，它又有什么样的本事敢这么定价。首先，咱们得明白，15.98万这个价格，是“补贴后”的价格。这意味着它原本的定价肯定是要高一些的，而这个价格能落地，.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有