std::async

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

• 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.

[Bearbeiten] Parameter

[Bearbeiten] Rückgabewert

[Bearbeiten] Ausnahmen

[Bearbeiten] Notes

[Bearbeiten] 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';
}

The sum is 10000