std::async – cppreference.com

<tbody> </tbody>

1)

2)

• Wenn die async Flag gesetzt ist (dh policy & std::launch::async != 0), dann async startet einen neuen Thread der Ausführung wie von std::thread(f, args...), außer dass, wenn die Funktion f einen Wert zurückgibt oder eine Ausnahme auslöst, wird es in der gemeinsamen Staat zugänglich aufbewahrt durch die std::future, dass async zum Aufrufer zurückkehrt .

  Original:

  If the async flag is set (i.e. policy & std::launch::async != 0), then async spawns a new thread of execution as if by std::thread(f, 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.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Wenn die latenten Flag gesetzt ist (dh policy & std::launch::deferred != 0), dann async Konvertiten args... die gleiche Weise wie std::thread Konstruktor, aber nicht laichen einen neuen Thread. Stattdessen wird lazy evaluation durchgeführt: Der erste Anruf wird zu einer nicht-Zeitüberschreitung warten Funktion auf dem std::future, dass async an den Aufrufer zurückgegeben verursachen f(args...) in den aktuellen Thread ausgeführt werden. Alle weiteren Zugriffen auf den gleichen std::future wird das Ergebnis sofort zurück .

  Original:

  If the deferred flag is set (i.e. policy & std::launch::deferred != 0), then async converts args... the same way as by std::thread constructor, but does not spawn a new thread of execution. Instead, lazy evaluation is performed: the first call to a non-timed wait function on the std::future that async returned to the caller will cause f(args...) to be executed in the current thread. All further accesses to the same std::future will return the result immediately.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Wenn sowohl die std::launch::async und std::launch::deferred Flaggen in policy gesetzt sind, ist es an der Umsetzung, ob asynchrone Ausführung oder faul Auswertung durchführen .

  Original:

  If both the std::launch::async and std::launch::deferred flags are set in policy, it is up to the implementation whether to perform asynchronous execution or lazy evaluation.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

Parameter

Rückgabewert

Ausnahmen

Notes

Beispiel

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <future>

template <typename RAIter>
int parallel_sum(RAIter beg, RAIter end)
{
    typename RAIter::difference_type len = end-beg;
    if(len < 1000)
        return std::accumulate(beg, end, 0);

    RAIter mid = beg + len/2;
    auto handle = std::async(std::launch::async,
                              parallel_sum<RAIter>, mid, end);
    int sum = parallel_sum(beg, mid);
    return sum + handle.get();
}

int main()
{
    std::vector<int> v(10000, 1);
    std::cout << "The sum is " << parallel_sum(v.begin(), v.end()) << '\n';
}