Lo c++ proporciona la biblioteca estándar APIpara ejecutar tareas (pasadas como argumentos) de forma asíncrona (creando un subproceso separado) o sincrónicamente (llamando a una función normalmente). Depende de la estrategia de lanzamiento.

parámetro

fel objeto invocable ( Callable) para invocar
args fparámetros pasados a
policyvalor de máscara de bits, cada bit individual controla qué métodos de ejecución están permitidos

poco	explicar
`std::launch::async`	Habilita la evaluación asíncrona, ejecutando un nuevo subproceso para realizar tareas de forma asíncrona
`std::launch::deferred`	Habilite la evaluación diferida, realice tareas en el subproceso de llamada (evaluación diferida). La ejecución se realiza al llamar `future`y `get` . `wait`Si no sucede nada, entonces la función de ejecución no se ejecutó.
`launch::async\|launch::deferred`	Esto es automático, la función selecciona automáticamente una estrategia en un punto determinado. Esto depende del sistema y de la implementación de la biblioteca, que generalmente está optimizada para la disponibilidad actual de concurrencia en el sistema.

Nota: Al llamar a async(f, 1, 2, 3) sin un argumento de estrategia, seleccionaremos la estrategia utilizada por ambos. Una implementación asíncrona es libre de elegir su estrategia. Esto también significa que no podemos estar seguros de si la tarea se ejecutará en un hilo nuevo o en el hilo actual.

iniciar estrategia

La estrategia de lanzamiento es std::async APIparte de , que se pasa como primer argumento. Hay tres estrategias de lanzamiento:

std::lanzamiento::async
std::lanzamiento::diferido
estrategia predeterminada (std::launch::async | std::launch::deferred)

std::lanzamiento::async

Inicia la función como un hilo separado y si el recurso no está disponible, obtendremos una excepción ( std::system_error error std::resource::unavailable_try_again).
ejemplo:

//创建单独的线程
std::future<int>result1=std::async(std::launch::async,AddThread,3,3);

std::lanzamiento::diferido

Inicia la función como una llamada síncrona cuando o cuando futurese llama . Si alguien inicia async con una estrategia diferida y no llama a or of , la función nunca se iniciará. ejemplo:get() wait() futureget() wait()

//Using std::launch::deferred policy, no separate thread.
auto result2 = std::async(std::launch::deferred, MulThread, 3, 3);

política predeterminada

Es una combinación de las dos estrategias anteriores o se deja en blanco (vea los ejemplos a continuación), inicia la función de forma asíncrona (creando un hilo separado) o sincrónicamente (llamando a la función normalmente), depende de la biblioteca, la biblioteca elegirá según el arriba Una de las políticas es sobre la disponibilidad de recursos.
ejemplo:

//Using Default Policy
//Both below function signature are same, we can use anyone.
std::async(std::launch::async|std::launch::deferred, AddThread, 6, 6);
or
std::async(AddThread, 6, 6);

ejemplo completo

Ejemplo 1:

#include <future>
#include <iostream>
// 检查它是否是质数
// 参数是必须检查的数字
bool fnprime(int num) {
    
    
    std::cout << "处理开始。。。请等待。。。\n";
    int i = 1;

    while (1) {
    
    
        std::cout << "处理数值" << num << "  " << i << std::endl;
        i++;
        if (i > 100) {
    
    
            break;
        }
    }
    for (; i < num + 100; ++i) {
    
    
        // 如果 mod 为0，返回 false，否则返回0

        std::cout << "处理数值" << num << "  " << i << std::endl;
    }
    return true;
}
// main method
int main() {
    
    
    int num = 20;
    // 异步调用函数 fnprime ()检查数字是否为质数:
    std::future<bool> fobj = std::async(std::launch::async, [&]() -> bool {
    
    
        std::cout << "处理开始。。。请等待。。。\n";
        int i = 1;

        while (1) {
    
    
            std::cout << "处理数值" << num << "  " << i << std::endl;
            i++;
            if (i > 100) {
    
    
                break;
            }
        }
        for (; i < num + 100; ++i) {
    
    
            // 如果 mod 为0，返回 false，否则返回0

            std::cout << "处理数值" << num << "  " << i << std::endl;
        }
        return true;
    });
    // 打印该行以显示状态
    std::cout << "检查数字4是否为质数 . . \n";
    // 等待函数 fnPrime 返回
    // bool bobj = fobj.get();
    if (true)
        std::cout << "给出的数字是质数 . . .  ! \n";
    else
        std::cout << "给出的数字不是质数 . . .  ! \n\n";
    return 0;
}

g++ -std=c++11 -pthread ...

检查数字4是否为质数 . . 
给出的数字是质数 . . .  ! 
处理开始。。。请等待。。。
处理数值20  1
处理数值20  2
...

Ejemplo 2

// library for std::cout
#include <iostream>
// library for std::async and std::future
#include <future>
// library for std::string
#include <string>
std::string samplefunction(const std::string& st) {
    
    
    return "This is the output of " + st;
}
class SamplefunctionObject {
    
    
   public:
    std::string operator()(const std::string& st) const {
    
    
        return "This is the output of " + st;
    }
};
int main() {
    
    
    std::cout << std::endl;
    // future with the help of function
    auto ff = std::async(samplefunction, "sample function");
    // future with the help of function object
    SamplefunctionObject samplefunctionObject;
    auto ffo = std::async(samplefunctionObject, "sample function object");
    // future with the help of lambda function
    auto fl = std::async(
        [](const std::string& st) {
    
     return "This is the output of " + st; },
        " lambda function");
    std::cout << ff.get() << "\n" << ffo.get() << "\n" << fl.get() << std::endl;
    std::cout << std::endl;
}

This is the output of sample function
This is the output of sample function object
This is the output of  lambda function

Un estudio simple de C++std::async