std::thread和std::this_thread

---

前言

std::thread 是 C++11 标准库的一部分，提供了一个表示单个执行线程的类。它允许程序员在 C++ 程序中创建和控制线程，使得可以并行地执行任务。使用 std::thread，你可以启动新的线程并与主线程并发执行，从而提高应用程序的响应性和性能，特别是在多核处理器上。
std::this_thread 是 C++11 引入的一个命名空间，提供了一组与当前线程相关的函数。这些函数允许你控制当前线程的行为，比如让线程休眠、获取线程的ID，以及对线程的中断请求进行检查。

---

一、std::thread

1. 创建线程

一般情况下，可通过传入一个可调用对象及其参数给std::thread的构造函数来创建线程。
std::thread构造函数模板定义：

template< class F, class… Args >
explicit thread( F&& f, Args&&… args );

构造函数的特点：

• std::thread 的构造函数是模板实现的，这意味着它可以接受多种不同类型的可调用对象和参数。
• 传递给 std::thread 构造函数的参数会被完美转发（Perfect Forwarding）到线程函数中，这意味着参数的值和类型会保持不变。
• 创建 std::thread 对象的瞬间，新线程就会启动。
• std::thread 对象不能被复制，但可以被移动。这意味着你可以将线程对象从一个作用域转移到另一个作用域，但不能复制它们。

2. 使用std::bind 创建线程

std::bind 是 C++11 引入的一个功能，允许你预先绑定函数调用的一部分或全部参数。当与 std::thread 结合使用时，std::bind 可以用来创建线程，尤其是在需要调用参数不完全匹配的函数时非常有用。
示例代码：

#include <iostream>
#include <thread>
#include <functional> // 对于 std::bind

class Foo {
public:
    void bar(int x) {
        std::cout << "Value: " << x << std::endl;
    }
};

int main() {
    Foo foo;
    int x = 42;

    // 使用 std::bind 绑定成员函数和参数
    auto boundFunc = std::bind(&Foo::bar, &foo, x);

    // 创建一个新线程来执行绑定的函数
    std::thread t(boundFunc);

    // 等待线程完成
    t.join();

    return 0;
}

使用 std::bind 可以让你灵活地处理函数参数，特别是当你不能直接修改目标函数签名时。
std::bind 创建的是一个可调用对象，这意味着你可以将其存储、传递和在任何可以调用普通函数的地方使用它。
std::bind 返回一个新的可调用对象，这个对象可以存储起来，稍后再调用，或者直接作为参数传递给其他函数，如线程构造函数。这个返回的可调用对象在被调用时会执行原始的可调用对象，使用绑定时指定的参数和/或调用时提供的参数。
返回的可调用对象类型是未指定的。这意味着你不能依赖于返回类型是特定的类型，但它会支持函数调用操作符。通常直接使用 auto 关键字来存储 std::bind 的返回值，或者将其作为参数直接传递给需要可调用对象的函数或对象构造器中。
示例代码：

#include <functional>
#include <iostream>

void print(int a, int b, int c) {
    std::cout << a << ", " << b << ", " << c << std::endl;
}

int main() {
    // 使用 std::placeholders::_1 作为第二个参数的占位符
    auto bindFunc = std::bind(print, 2, std::placeholders::_1, 4);
    
    // 这时只需要提供被 std::placeholders::_1 占位的参数
    bindFunc(3);  // 输出: 2, 3, 4

    return 0;
}

3. 线程操作

• join()：阻塞当前线程，直到由 std::thread 对象表示的线程完成其执行。一个线程必须是可连接的才能被加入。
• detach()：分离线程，允许线程独立执行。一旦线程被分离，它就不能再被加入。
• joinable()：检查线程是否是可连接的，即它是否代表了一个正在执行的线程。
• get_id()：获取线程的ID，如果线程是可连接的，则返回一个标识该线程的唯一ID；否则，返回一个默认构造的std::thread::id。
• swap(std::thread& other)：交换两个线程对象所代表的线程。

4. 注意事项

• 资源管理：使用 std::thread 需要注意资源管理，确保每个线程要么被加入（join()），要么被分离（detach()）。
  创建线程后，你必须决定在某个时点调用 join() 或 detach() 方法。调用 join() 方法会使主线程等待新创建的线程完成执行。如果选择 detach() 方法，则新线程将在后台运行，允许执行线程独立于主线程继续运行。无论选择哪种方法，都是为了确保程序的正确同步和资源的正确管理。
• 异常安全：如果在调用 join() 或 detach() 之前发生异常，程序可能会终止。
• 在 std::thread 对象的生命周期结束之前，你必须明确地决定是调用 join() 还是 detach()，否则，如果到达 std::thread 对象的析构函数时线程仍然是可连接的（即没有被分离或加入），程序将调用 std::terminate() 来终止执行。这是因为丢弃一个仍在执行的线程可能会导致不可预测的行为和资源泄露。
• 只有通过显式调用 detach()，线程才被认为是独立执行的。在这种情况下，线程的生命周期与创建它的程序的其他部分独立，不需要等待线程结束即可继续执行程序的其他部分。独立执行的线程在完成任务后会自行清理资源。

二、std::this_thread

下面介绍std::this_thread命名空间中的一些常用函数。

1.sleep_for

使当前线程休眠一定时间。

void sleep_for( const std::chrono::duration<Rep, Period>& duration );

2. sleep_until

使当前线程休眠直到指定的时间点。

void sleep_until( const std::chrono::time_point<Clock, Duration>& time_point );

3. yield

让出当前线程的执行权，给予执行器一个提示，表明当前线程可以被暂时挂起，以便其他线程可以运行。

void yield();

调用 std::this_thread::yield() 会给执行环境（操作系统的调度器）一个提示，表明当前线程愿意放弃其剩余的时间片，以允许其他线程运行。这是一个向调度器建议“现在可以切换到另一个线程”的方式，但这并不保证调度器一定会这么做。调度器可能会立即重新调度相同的线程，也可能选择另一个线程运行。

当前线程重新被调度执行的时机:

1. 调度器决定：重新调度当前线程的具体时机取决于操作系统的调度策略和当前的系统负载。如果系统中有其他线程准备好运行，当前线程可能会等待一段时间。但如果没有其他线程需要运行，当前线程可能会几乎立即被重新调度。
2. 时间片轮转：在某些操作系统中，调度器可能会使用时间片轮转（round-robin）调度策略，此时，线程会在一个相对公平的时间间隔后被重新调度。

使用 yield() 的目的:

1. 改善并发性能
2. 提高应用响应性

4. get_id

获取当前线程的ID。

std::thread::id get_id();

三、使用并发管理工具（最佳实践）

通常建议谨慎使用 detach()，因为一旦线程被分离，就很难保证它的执行状态和资源的正确管理。如果可能，最好使用 join()，或考虑使用更高级的并发管理工具，如 std::async 和 std::future，这些工具提供了更容易管理的并发执行模型。如果确实需要使用分离的线程，确保正确管理与线程执行相关的资源和错误处理是非常重要的。

auto future = std::async(LaunchPolicy policy, Callable&& f, Args&&... args);

示例代码：

#include <iostream>
#include <future>
#include <chrono>

// 一个简单的函数，模拟耗时的计算任务
int LongComputation(int x) {
    // 模拟耗时操作
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return x * x;
}

int main() {
    // 使用 std::async 启动一个异步任务
    std::future<int> result = std::async(LongComputation, 4);

    // 在等待结果时可以做一些其他的工作
    // （这里我们只是简单地输出一些文本）
    std::cout << "Waiting for the result..." << std::endl;

    // 使用 .get() 来获取异步操作的结果，这会阻塞直到结果准备就绪
    std::cout << "Result: " << result.get() << std::endl;

    // 注意：调用 .get() 后，该 future 对象不能再次使用

    return 0;
}

---