7

我知道了future返回 from的原因std::async有一些特殊的共享状态，通过这种共享状态wait on returned future发生在未来的析构函数中。但是当我们使用 时std::pakaged_task，它的未来不会表现出相同的行为。要完成打包任务，您必须显式调用get()来自 的future对象packaged_task。

现在我的问题是：

  1. std::async未来（thinking vs ）的内部实现可能是什么std::packaged_task？
  2. 为什么相同的行为不适用于future返回 from std::packaged_task？或者，换句话说，如何停止相同的行为std::packaged_task future？

要查看上下文，请参阅以下代码：

它不等待完成countdown任务。但是，如果我取消评论// int value = ret.get();，它将完成countdown并且很明显，因为我们实际上是在阻止返回的未来。

    // packaged_task example
#include <iostream>     // std::cout
#include <future>       // std::packaged_task, std::future
#include <chrono>       // std::chrono::seconds
#include <thread>       // std::thread, std::this_thread::sleep_for

// count down taking a second for each value:
int countdown (int from, int to) {
  for (int i=from; i!=to; --i) {
    std::cout << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
  std::cout << "Lift off!" <<std::endl;
  return from-to;
}

int main ()
{
   std::cout << "Start " << std::endl;
  std::packaged_task<int(int,int)> tsk (countdown);   // set up packaged_task
  std::future<int> ret = tsk.get_future();            // get future

  std::thread th (std::move(tsk),10,0);   // spawn thread to count down from 10 to 0

//   int value = ret.get();                  // wait for the task to finish and get result

  std::cout << "The countdown lasted for " << std::endl;//<< value << " seconds.\n";

  th.detach();   

  return 0;
}

如果我使用在另一个线程上std::async执行任务countdown，无论我是否在get()返回的future对象上使用，它都会完成任务。

// packaged_task example
#include <iostream>     // std::cout
#include <future>       // std::packaged_task, std::future
#include <chrono>       // std::chrono::seconds
#include <thread>       // std::thread, std::this_thread::sleep_for

    // count down taking a second for each value:
    int countdown (int from, int to) {
      for (int i=from; i!=to; --i) {
        std::cout << i << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
      }
      std::cout << "Lift off!" <<std::endl;
      return from-to;
    }
    
    int main ()
    {
       std::cout << "Start " << std::endl;
      std::packaged_task<int(int,int)> tsk (countdown);   // set up packaged_task
      std::future<int> ret = tsk.get_future();            // get future
    
      auto fut = std::async(std::move(tsk), 10, 0);   

    
    //   int value = fut.get();                  // wait for the task to finish and get result
    
      std::cout << "The countdown lasted for " << std::endl;//<< value << " seconds.\n";

      return 0;
    }
4

3 回答 3

5

std::async对如何以及在何处执行给定的任务有明确的了解。这就是它的工作：执行任务。要做到这一点，它必须把它放在某个地方。那个地方可能是一个线程池，一个新创建的线程，或者在一个由谁破坏future.

因为async知道函数将如何执行，所以它拥有 100% 的信息来构建一种机制，该机制可以在潜在的异步执行结束时进行通信，并确保如果你破坏future了执行该函数最终将绕过实际执行它。毕竟，它知道那个机制是什么。

但packaged_task 没有。所做的只是存储一个packaged_task可以使用给定参数调用的可调用对象，使用promise函数返回值的类型创建 a，并提供一种获取 afuture和执行生成该值的函数的方法。

任务实际执行的时间和地点无关紧要packaged_task。future如果没有这些知识，就无法构建使 's 析构函数与任务同步所需的同步。

假设您想在新创建的线程上执行任务。好的，因此要将其执行与future' 销毁同步，您需要一个互斥锁，析构函数将阻塞该互斥锁，直到任务线程完成。

future但是，如果您想在与析构函数的调用者相同的线程中执行任务怎么办？好吧，那么您不能使用互斥锁来同步它，因为它们都在同一个线程上。相反，您需要让析构函数调用该任务。这是一个完全不同的机制，它取决于你计划如何执行。

因为packaged_task不知道您打算如何执行它，所以它无法执行任何操作。

请注意，这不是packaged_task. 从用户创建的对象创建的所有 s都不会具有s的特殊属性。futurepromiseasyncfuture

所以问题真的应该是为什么这样async工作，而不是为什么其他人不这样做。

如果您想知道这一点，那是因为两个相互竞争的需求：async需要是一种高级的、脑死亡的简单方法来获得异步执行（破坏时同步是有意义的），并且没有人想创建一个新的future除了析构函数的行为外，它与现有的类型相同。所以他们决定重载如何future工作，使其实现和使用复杂化。

于 2020-10-15T01:43:30.363 回答
5

@Nicol Bolas已经非常令人满意地回答了这个问题。因此，我将尝试从不同的角度稍微回答这个问题，详细说明@Nicol Bolas 已经提到的观点。

相关事物的设计及其目标

考虑我们想要以各种方式执行的这个简单函数：

int add(int a, int b) {
    std::cout << "adding: " << a << ", "<< b << std::endl;
    return a + b;
}

忘记吧std::packaged_task，暂时让我们退后一步，重新审视它是如何std ::future工作的以及它会导致什么问题。std::asyncstd::function

案例 1 — std::function不足以在不同的线程中执行事物

std::function<int(int,int)> f { add };

一旦有了f，我们就可以在同一个线程中执行它，例如：

int result = f(1, 2); //note we can get the result here

或者，在不同的线程中，像这样：

std::thread t { std::move(f), 3, 4 };
t.join();

如果我们仔细看，我们会意识到f在不同的线程中执行会产生一个新问题：我们如何获得函数的结果？在同一个线程中执行f没有这个问题——我们得到的结果是返回值，但是当它在不同的线程中执行时，我们没有任何办法得到结果。这正是解决的问题std::packaged_task。

案例2——std::packaged_task解决了std::function没有解决的问题

特别是，它在线程之间创建一个通道，以将结果发送到另一个线程。除此之外，它或多或少与std::function.

std::packaged_task<int(int,int)> f { add }; // almost same as before

std::future<int> channel = f.get_future();  // get the channel
    
std::thread t{ std::move(f), 30, 40 }; // same as before
t.join();  // same as before
    
int result = channel.get(); // problem solved: get the result from the channel

现在您了解如何std::packaged_task解决由std::function. 然而，这并不意味着std::packaged_task必须在不同的线程中执行。您也可以在同一个线程中执行它，就像 一样std::function，尽管您仍然会从通道中获得结果。

std::packaged_task<int(int,int)> f { add }; // same as before
std::future<int> channel = f.get_future(); // same as before
    
f(10, 20); // execute it in the current thread !!

int result = channel.get(); // same as before

所以从根本上说std::function，std::packaged_task它们是类似的东西：它们只是包装可调用实体，但有一个区别：std::packaged_task多线程友好，因为它提供了一个通道，通过它可以将结果传递给其他线程。他们俩都不自己执行包装的可调用实体。需要在同一个线程或另一个线程中调用它们来执行包装的可调用实体。所以基本上这个空间里有两种东西：

  • 执行什么，即常规函数，，，std::function等std::packaged_task。
  • 如何/在哪里执行，即线程、线程池、执行程序等。

案例3：std::async是完全不同的事情

这是另一回事，因为它结合了what-is-executed和how/where-is-executed。

std::future<int> fut = std::async(add, 100, 200);
int result = fut.get();

请注意，在这种情况下，创建的未来有一个关联的执行程序，这意味着未来将在某个时候完成，因为有人在幕后执行事情。然而，在由 创造的未来的情况下，std::packaged_task不一定有一个执行者，如果创建的任务从未交给任何执行者，那么未来可能永远不会完成。

希望这可以帮助您了解幕后的工作原理。请参阅在线演示。

两种的区别std::future

好吧，在这一点上，很明显std::future可以创建两种类型：

  • 一种可以由std::async. 这样的未来有一个关联的执行者，因此可以完成。
  • 其他类型可以由std::packaged_task或类似的东西创建。这样的未来不一定有关联的执行者，因此可能会也可能不会完成。

因为，在第二种情况下，future 不一定有关联的 executor，它的析构函数不是为它的完成/等待而设计的，因为它可能永远不会完成：

 {
   std::packaged_task<int(int,int)> f { add };
 
   std::future<int> fut = f.get_future(); 

 } // fut goes out of scope, but there is no point 
   // in waiting in its destructor, as it cannot complete 
   // because as `f` is not given to any executor.

希望这个答案可以帮助您从不同的角度理解事物。

于 2020-11-08T18:21:51.060 回答
1

std::thread行为的变化是由于和之间的差异std::async。

在第一个示例中，您通过分离创建了一个守护线程。您在主线程中打印的位置可能发生在线程函数std::cout << "The countdown lasted for " << std::endl;内的打印语句之前、期间或之后。countdown因为主线程不会等待生成的线程，所以您甚至可能看不到所有的打印输出。

在第二个示例中，您使用std::launch::deferred策略启动线程函数。std::async的行为是：

如果选择了异步策略，则关联的线程完成与第一个等待共享状态的函数的成功返回同步，或者与释放共享状态的最后一个函数的返回同步，以先到者为准。

在此示例中，您有两个用于相同共享状态的期货。在退出 main 时调用它们的 dtor 之前，必须完成异步任务。即使您没有明确定义任何未来，被创建和销毁的临时未来（从调用返回std::async）将意味着任务在主线程退出之前完成。

这是 Scott Meyers 的一篇很棒的博客文章，阐明了std::future&的行为std::async。

相关的 SO 帖子。

于 2020-10-11T09:55:22.803 回答