C++线程异步

std::future

std::future作为异步结果的传输通道，可以很方便地获取线程函数的返回值。

 std::future_status

1. Ready (std::future_status::ready):

   • 当与 std::future 对象关联的异步操作已经完成时，std::future 处于 ready 状态。
   • 在这个状态下，调用 get()、wait() 或 wait_for() 将立即返回，并且 get() 将返回操作的结果（或者抛出异常，如果操作以异常结束）。   

2. Timeout (std::future_status::timeout):

   • 当调用 wait_for() 或 wait_until() 并且指定的等待时间已经过去，但异步操作尚未完成时，std::future 处于 timeout 状态。
   • 这意味着 wait_for() 或 wait_until() 调用返回了 std::future_status::timeout，表明等待超时，但 std::future 仍然可能在未来某个时间点变为 ready 状态。

3. Deferred (std::future_status::deferred):

   • 当与 std::future 对象关联的异步操作是延迟执行的（即，它将在调用 get()、wait()时才执行），std::future 处于 deferred 状态。
   • 这种情况发生在使用 std::async 时指定了 std::launch::deferred，这意味着操作将在第一次调用 get()、wait() 或 wait_for() 时在当前线程上执行。 

状态转换图：

std::future 对象在其生命周期内只能从 deferred 状态转移到 ready 状态，或者从 ready 状态转移到 timeout 状态（仅在调用 wait_for() 或 wait_until() 时）。一旦 std::future 对象处于 ready 状态，它将保持这种状态直到其结果被获取或对象被销毁。如果异步操作在调用 wait_for() 或 wait_until() 之前完成，那么即使等待超时，std::future 对象也会处于 ready 状态。  

std::future::get() 

 std::future::wait

当使用 std::async、std::packaged_task 或 std::promise 创建异步任务时，你可以通过 std::future 对象来获取结果。std::future 提供了 wait 函数，用于阻塞当前线程，直到与 future 对象关联的共享状态变为就绪状态。

std::future::wait 的行为与 std::future::get 类似，但 wait 不会返回结果，它只是等待操作完成。如果你只是想确保操作完成而不需要立即获取结果，使用 wait 是合适的。 

需要注意的是，如果你在一个已经就绪的 future 上调用 wait，它将立即返回，而不会阻塞。如果你在一个处于 deferred 状态的 future 上调用 wait，它将执行关联的任务并等待其完成。 

#include <future>
#include <iostream>int main() {std::future<int> fut = std::async(std::launch::async, []() {// 异步执行一些操作return 42;});// 等待 future 完成fut.wait();// 获取结果std::cout << "Result: " << fut.get() << std::endl;return 0;
}

std::future::wait_for

它允许你等待一个 future 对象指定的时长。如果 future 在这段时间内变为就绪状态，wait_for 将返回 std::future_status，表明 future 的状态。

测试1： 

#include <future>
#include <iostream>
#include <chrono>int main() {// 创建一个异步任务std::future<int> fut = std::async(std::launch::async, []() {std::this_thread::sleep_for(std::chrono::seconds(5)); // 模拟耗时操作return 42;});// 等待 future 完成，最多等待 3 秒auto status = fut.wait_for(std::chrono::seconds(3));if (status == std::future_status::ready) {std::cout << "Future is ready. Result: " << fut.get() << std::endl;} else if (status == std::future_status::timeout) {std::cout << "Future is not ready within the given time." << std::endl;} else if (status == std::future_status::deferred) {std::cout << "Future is deferred and will execute in the calling thread." << std::endl;}return 0;
}

 Future is not ready within the given time.

 在这个例子中，我们创建了一个异步任务，它将在 5 秒后返回结果。我们使用 wait_for 来等待 future 完成，但只等待 3 秒。因此，wait_for 将返回 std::future_status::timeout，表明 future 在指定的 3 秒内没有准备好。

如果我们将 wait_for 的等待时间增加到超过 5 秒，那么 wait_for 将返回 std::future_status::ready，因为异步任务将在等待时间结束前完成。

测试2： 

我自己跑了下，改成5s还是不行：

测试3：

6s可以

 如果任务是以延迟方式执行的（即 std::launch::deferred），那么 wait_for 将返回 std::future_status::deferred。 

------------- 

线程异步操作函数async

std::async可以用来直接创建异步的task，异步任务返回的结果保存在future中。

(1)需要获取异步任务的结果时，调用future.get()方法即可。

(2)不关注异步任务的结果，只是简单地等待任务完成的话，调用future.wait()方法。

std::async的第一个参数: std::launch::async | std::launch::deferred

 std::launch::async ：在调用async时就开始创建线程

 std::launch::deferred ：延迟加载方式创建线程。调用async时不创建线程，

 直到调用了 future的get或者wait时才创建线程。

 std::async的第二个参数：线程函数

 std::async的第三个参数：线程函数的参数

示例： 

#include <future>
#include <iostream>int main() {// 使用 std::async 创建一个异步任务std::future<int> fut = std::async(std::launch::async, []() {// 异步任务执行一些计算并返回结果return 42;});// 在这里，主线程可能会执行其他任务...// 获取异步任务的结果int result = fut.get(); // 这将阻塞，直到异步任务完成std::cout << "The result is " << result << std::endl;return 0;
}

launch：启动（计算机程序）
sync：同时，同步；协调，一致

std::promise

std::promise将数据与future绑定起来，为获取线程函数中的某个值提供便利，在线程函数中为外面传过来的promise赋值，在线程函数执行完成之后就可以通过promise的future获取该值了。

取值是通过promise内部提供的future来获取的。

promise:承诺

#include <future>
#include <iostream>
#include <chrono>int main() {std::promise<int> pr;std::thread t([](std::promise<int>& p) {// 执行一些操作...p.set_value_at_thread_exit(9); // 在线程退出时设置值}, std::ref(pr));std::future<int> f = pr.get_future();// 等待子线程完成t.join();// 现在可以安全地获取值auto r = f.get();std::cout << "Received: " << r << std::endl;return 0;
}

Received: 9

set_value_at_thread_exit

它允许你设置一个值，这个值将在当前线程退出时传递给与之关联的 std::future 对象

在当前线程退出时，应该将给定的值传递给 std::future。这可以确保即使线程在设置值后立即退出，相关的值也会被存储，并且可以在其他地方通过 std::future 对象获取。

• 它在 std::promise 类中声明。
• 它接受一个值，这个值可以是任何可复制的类型。
• 它不会立即设置值，而是在当前线程退出时设置值。
• 调用 set_value_at_thread_exit 后，std::promise 对象处于就绪状态，即 future::valid() 为 true。
• 一旦 set_value_at_thread_exit 被调用，你就不能再通过这个 std::promise 对象设置另一个值。

“任何可复制的类型” 指的是那些可以被复制构造函数或复制赋值运算符安全复制的类型。这意味着这些类型的对象可以被创建为其他同类对象的副本，而不会导致未定义行为。 

std::ref

 std::ref 用于创建一个包装器，这个包装器能够将引用传递给接受值传递的函数。这在需要将引用传递给像线程函数或函数对象这样的参数时非常有用。

以下是一些使用 std::ref 的例子： 

1. 将引用传递给线程函数

通常情况下，当创建一个线程时，你传递给 std::thread 构造函数的参数是通过值传递的。如果你想要传递一个引用，你可以使用 std::ref。

#include <iostream>
#include <thread>
#include <functional>void func(int& n) {n++;
}int main() {int n = 0;std::thread t(func, std::ref(n));t.join();std::cout << "n = " << n << std::endl; // 输出 n = 1return 0;
}

在上面的例子中，std::ref(n) 创建了一个引用包装器，使得 func 函数能够通过引用修改 n。

--------- 

2. 将引用传递给函数对象

std::ref 也可以用于将引用传递给函数对象。

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>struct Increment {void operator()(int& n) {n++;}
};int main() {std::vector<int> vec = {1, 2, 3, 4, 5};std::for_each(vec.begin(), vec.end(), Increment());std::for_each(vec.begin(), vec.end(), Increment());for (int n : vec) {std::cout << n << ' '; // 输出 3 4 5 6 7}std::cout << std::endl;return 0;
}

std::for_each 接受一个函数对象 Increment，并且因为 Increment 接受一个引用参数，所以不需要使用 std::ref。但是，如果函数对象是通过值传递参数的，使用 std::ref 可以确保传递的是引用。 

---------- 

记住，std::ref 只在需要引用语义时使用。如果你不需要修改原始对象，或者函数接受的是按值传递的参数，那么使用 std::ref 是不必要的。 

--------- 

std::for_each

 std::for_each 是 C++ 标准库中的一个算法，它用于对容器中的每个元素执行一个操作。这个算法会遍历指定范围内的所有元素，并对每个元素调用提供的函数或函数对象。

 template< class InputIt, class UnaryFunction >
UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f ); 

unary:一元的 

• InputIt first, InputIt last: 这两个参数定义了要遍历的元素范围。通常，它们是容器的迭代器。
• UnaryFunction f: 这是一个函数或函数对象，它将被应用于范围内的每个元素。这个函数或函数对象应该接受一个参数，对应于范围内的每个元素.

由于我们正在修改容器中的元素，迭代器必须是能够修改元素的类型，即随机访问迭代器。在 std::vector 中，begin() 和 end() 返回的迭代器就是这种类型。 

 std::for_each 是 C++ 标准库中的一个算法，它用于对容器中的每个元素执行一个操作。这个算法会遍历指定范围内的所有元素，并对每个元素调用提供的函数或函数对象。

 template< class InputIt, class UnaryFunction >
UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f ); 

unary:一元的 

• InputIt first, InputIt last: 这两个参数定义了要遍历的元素范围。通常，它们是容器的迭代器。
• UnaryFunction f: 这是一个函数或函数对象，它将被应用于范围内的每个元素。这个函数或函数对象应该接受一个参数，对应于范围内的每个元素.

由于我们正在修改容器中的元素，迭代器必须是能够修改元素的类型，即随机访问迭代器。在 std::vector 中，begin() 和 end() 返回的迭代器就是这种类型。 

----------

传递给 std::thread 构造函数的参数默认是通过值传递的

 当创建一个 std::thread 对象时，传递给 std::thread 构造函数的参数默认是通过值传递的。这意味着，如果传递的是非引用类型，那么线程函数将会接收到传递参数的一个副本。

#include <iostream>
#include <thread>void threadFunction(int n) {// 这里我们接收到的是 n 的副本n += 100;std::cout << "Inside thread: " << n << std::endl;
}int main() {int n = 1;std::thread t(threadFunction, n); // 传递 n 的副本t.join();std::cout << "Outside thread: " << n << std::endl; // n 仍然是 1return 0;
}

 如果我们想要在线程函数中修改原始变量，就需要传递一个引用。但是，由于 std::thread 构造函数默认是按值传递的，因此需要使用 std::ref 来传递引用

#include <iostream>
#include <thread>
#include <functional>void threadFunction(int& n) {n += 100;std::cout << "Inside thread: " << n << std::endl;
}int main() {int n = 1;std::thread t(threadFunction, std::ref(n)); // 使用 std::ref 传递引用t.join();std::cout << "Outside thread: " << n << std::endl; // n 现在是 101return 0;
}

 这就是 std::ref 的用途所在，它允许在线程或其他按值传递参数的上下文中传递引用。

---------

线程退出

线程的退出时机取决于线程的执行逻辑和线程的创建方式。以下是几种情况下线程可能退出的时机：

1. 任务完成退出：线程执行的任务完成后，线程函数（无论是普通函数、成员函数还是 lambda 表达式）会执行返回语句。当线程函数返回时，线程会自然退出。这是线程退出的最常见方式。

2. 自毁退出：在 C++ 中，当 std::thread 对象被销毁时，如果关联的线程仍在运行，std::thread 的析构函数会调用 std::terminate 来终止程序，除非：

   • 线程已经完成了它的执行（任务完成）。
   • 线程是通过 std::detach 被分离的。
   • 线程被 join 过，且 std::thread 对象是通过移动构造或移动赋值创建的。

3. 分离退出：如果线程被分离（使用 std::thread::detach），它将在后台运行，与创建它的 std::thread 对象无关。线程将在执行完毕后自动退出，资源被系统回收。

4. 异常退出：如果线程执行的函数抛出了未捕获的异常，并且没有设置相应的异常处理机制，线程将异常退出。

5. 外部干预退出：线程可以被外部干预强制退出，例如：

   • 调用 pthread_cancel（在 POSIX 线程中）来请求取消线程。
   • 在 Windows 中，可以通过调用 TerminateThread 或 ExitThread 来终止线程，但这通常是不安全的做法，因为它可能导致资源泄露和其他问题。

6. 程序终止：当主线程退出时，如果其他线程是可连接的（joinable），程序通常会调用 std::terminate 来终止这些线程。如果其他线程是分离的，它们可能在主线程退出后继续运行，直到完成或被系统强制终止。

为了确保资源得到正确释放，线程应当尽可能通过自然的退出路径结束，例如任务完成或通过 join 等待线程结束。避免使用强制退出线程的方法，因为这可能会导致不一致的状态和资源泄露。

1. 移动构造和移动赋值：当一个 std::thread 对象是通过移动构造或移动赋值创建的，它会接手源对象所管理的线程，而源对象将不再管理任何线程（即变为非.joinable状态）。

2. 被 join 过的 std::thread：如果一个 std::thread 对象已经调用了 join，那么它将不再管理任何线程，也就是说它变成了非.joinable状态。在这种情况下，再次调用 join 是不允许的，将会导致未定义行为。