如果不这样做，新线程上的函数 运行 "as if" 怎么可能呢？
How can a function run "as if" on a new thread without doing so?
根据 C++ 标准的 [futures.async]/3 项目符号 1，当使用 std::launch::async 启动策略将函数 f 传递给 std::async 时，f 将 运行 "as if in a new thread of execution"。
鉴于 f 可以做任何事情，包括无限循环和永远阻塞，一个实现如何在它自己的线程上提供 f 运行ning 的行为而实际上 运行将它放在自己的线程上？也就是说，实施如何利用标准提供的 "as if" 回旋余地？
我能想到的一些方法 f 可以 运行 "as if" 在新线程上而不实际这样做，如果 f 实际上不使用任何状态与其他线程共享；那么实现可以 运行 它作为一个单独的进程（因为它不需要共享内存 space）它也可以 运行 它在主线程上作为另一个函数调用（如果它可以证明 f 不会阻塞或具有可观察到的副作用，当 运行 这种方式时会有所不同）。它也可以安排到 运行 现有（但空闲）线程（线程池）上。
如果你想变得愚蠢，我想你也可以考虑 运行ning f at all 的概念，因为有无法保证操作系统何时将新线程调度到 运行，因此一个邪恶的实现可能只是说 OS 从不调度除主线程之外的任何线程，因此不会调度 运行 ning f 完全相当于在一个新线程上调度它。当然，这是 stupid/silly 并且没有理智的实现会这样做 - 但在 理论 中，语言允许这种退化的实现（我认为）。
AFAIK C++ 运行time 能够管理一些内部（或专用）线程，区别于标准线程。
我的猜测（我仍在学习 C++ 的高级功能）是，使用 std::launch::async 标志，std::async() 将在新的 [=34] 中启动 f =]内部线程。
您可以使用 std::thread 在新的 标准 线程中启动 f。在这种情况下，异常将在被调用线程上处理，主代码必须获取 f.
的 return 值
使用内部线程，return值和最终异常被存储到std::future，return由[=11编辑=] 并在线程之间共享。
所以"as if"代表"as if I launch f with std::thread but I don't have to"。但可以肯定的是，f 将 运行 在新线程上。
要回答您关于实现的问题，一旦 运行time 已经实现了 standard 线程，只需努力将它们专门用于特定用途。另见 execution policy for algorithms that support parallelization.
在 C++ 引用中看起来 here and here，似乎 "as if" 目标是让库实现者有一定的自由度。例如，它说
as if spawned by std::thread(std::forward(f),
std::forward(args)...), except that if the function f returns a
value or throws an exception, it is stored in the shared state
accessible through the std::future that async returns to the caller.
在第一个来源中，
as if a thread object is constructed with fn and args as arguments,
and accessing the shared state of the returned future joins it
在第二个。所以看起来行为类似于 std::thread 的行为，但可能以不同的方式实现。这很有趣，因为您在此处引用的 thread of execution 短语与 std::thread 不同。不过，似乎这两个消息来源都以这种方式理解 as-if。
另一种选择可能是，正如 François Andrieux 所建议的那样，允许使用线程池，如第一个来源中所述：
The template function async runs the function f asynchronously
(potentially in a separate thread which may be part of a thread pool)
此解决方案的优势在于，当您针对多线程世界中的特定角色优化实现时。由于我参与了软件更新程序，因此我将使用这样的示例。
出于优化原因，您可以调用：
std::thread::hardware_concurrency();
您将收到：
Returns the number of concurrent threads supported by the
implementation.
假设您的结果等于 4。
您想并行执行更新许多事情。
主线程正在监视期货列表（剩下 3 个）并不时检查它是否完成，如果完成则执行 ToDo 列表中的下一件事。例如，如果您正在更新不同类型的内存，如 1-FileSystem、2-EEPROM、3-NOR 内存或类似内存，则此处的利润。
没有延迟地检查循环没有任何好处，因此您想在检查之间将任务交给第 4 个线程。
您正在编写用于挖掘比特币 50 毫秒的函数 :)
并且您在检查之间延迟触发它。
然后正如您提到的，我们有：
advantage of the "as if" wiggle room the Standard provides
我看到 "f will run " 的主要思想就像在一个新的执行线程中一样"" 是 f 将 运行 异步。是新线程还是其他是实现细节。
没有线程的唯一解决方案，我能想到的是昨天的时间切片，这是一种多任务处理形式。必须使函数可重入。在这种情况下，每个函数都会 运行 就好像它们在不同的线程上一样，尽管实际上它们在单个线程上。
在文档中，它在那里说明，
模板函数 async 异步运行函数 f（可能在一个单独的线程中，它可能是线程池的一部分） 和 returns a std::future 最终将保存该函数调用的结果。
根据 C++ 标准的 [futures.async]/3 项目符号 1，当使用 std::launch::async 启动策略将函数 f 传递给 std::async 时，f 将 运行 "as if in a new thread of execution"。
鉴于 f 可以做任何事情，包括无限循环和永远阻塞，一个实现如何在它自己的线程上提供 f 运行ning 的行为而实际上 运行将它放在自己的线程上？也就是说，实施如何利用标准提供的 "as if" 回旋余地？
我能想到的一些方法 f 可以 运行 "as if" 在新线程上而不实际这样做，如果 f 实际上不使用任何状态与其他线程共享；那么实现可以 运行 它作为一个单独的进程（因为它不需要共享内存 space）它也可以 运行 它在主线程上作为另一个函数调用（如果它可以证明 f 不会阻塞或具有可观察到的副作用，当 运行 这种方式时会有所不同）。它也可以安排到 运行 现有（但空闲）线程（线程池）上。
如果你想变得愚蠢，我想你也可以考虑 运行ning f at all 的概念，因为有无法保证操作系统何时将新线程调度到 运行，因此一个邪恶的实现可能只是说 OS 从不调度除主线程之外的任何线程，因此不会调度 运行 ning f 完全相当于在一个新线程上调度它。当然，这是 stupid/silly 并且没有理智的实现会这样做 - 但在 理论 中，语言允许这种退化的实现（我认为）。
AFAIK C++ 运行time 能够管理一些内部（或专用）线程，区别于标准线程。
我的猜测（我仍在学习 C++ 的高级功能）是，使用 std::launch::async 标志，std::async() 将在新的 [=34] 中启动 f =]内部线程。
您可以使用 std::thread 在新的 标准 线程中启动 f。在这种情况下，异常将在被调用线程上处理，主代码必须获取 f.
使用内部线程，return值和最终异常被存储到std::future，return由[=11编辑=] 并在线程之间共享。
所以"as if"代表"as if I launch f with std::thread but I don't have to"。但可以肯定的是，f 将 运行 在新线程上。
要回答您关于实现的问题，一旦 运行time 已经实现了 standard 线程，只需努力将它们专门用于特定用途。另见 execution policy for algorithms that support parallelization.
在 C++ 引用中看起来 here and here，似乎 "as if" 目标是让库实现者有一定的自由度。例如，它说
as if spawned by std::thread(std::forward(f), std::forward(args)...), except that if the function f returns a value or throws an exception, it is stored in the shared state accessible through the std::future that async returns to the caller.
在第一个来源中，
as if a thread object is constructed with fn and args as arguments, and accessing the shared state of the returned future joins it
在第二个。所以看起来行为类似于 std::thread 的行为，但可能以不同的方式实现。这很有趣，因为您在此处引用的 thread of execution 短语与 std::thread 不同。不过，似乎这两个消息来源都以这种方式理解 as-if。
另一种选择可能是，正如 François Andrieux 所建议的那样，允许使用线程池，如第一个来源中所述：
The template function async runs the function f asynchronously (potentially in a separate thread which may be part of a thread pool)
此解决方案的优势在于，当您针对多线程世界中的特定角色优化实现时。由于我参与了软件更新程序，因此我将使用这样的示例。 出于优化原因，您可以调用：
std::thread::hardware_concurrency();
您将收到：
Returns the number of concurrent threads supported by the implementation.
假设您的结果等于 4。 您想并行执行更新许多事情。 主线程正在监视期货列表（剩下 3 个）并不时检查它是否完成，如果完成则执行 ToDo 列表中的下一件事。例如，如果您正在更新不同类型的内存，如 1-FileSystem、2-EEPROM、3-NOR 内存或类似内存，则此处的利润。 没有延迟地检查循环没有任何好处，因此您想在检查之间将任务交给第 4 个线程。 您正在编写用于挖掘比特币 50 毫秒的函数 :) 并且您在检查之间延迟触发它。
然后正如您提到的，我们有：
advantage of the "as if" wiggle room the Standard provides
我看到 "f will run " 的主要思想就像在一个新的执行线程中一样"" 是 f 将 运行 异步。是新线程还是其他是实现细节。
没有线程的唯一解决方案，我能想到的是昨天的时间切片，这是一种多任务处理形式。必须使函数可重入。在这种情况下，每个函数都会 运行 就好像它们在不同的线程上一样，尽管实际上它们在单个线程上。
在文档中，它在那里说明，
模板函数 async 异步运行函数 f（可能在一个单独的线程中，它可能是线程池的一部分） 和 returns a std::future 最终将保存该函数调用的结果。