Namensräume
Varianten

    std::async

    Aus cppreference.com
    < cpp‎ | thread

    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


     
    C++
     
    Thema Support-Bibliothek
    Threads
    Original:
    Threads
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    thread(C++11)
    this_thread Namespace
    Original:
    this_thread namespace
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    get_id(C++11)
    yield(C++11)
    sleep_for(C++11)
    sleep_until(C++11)
    Gegenseitigen Ausschluss
    Original:
    Mutual exclusion
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    mutex(C++11)
    timed_mutex(C++11)
    Generische Sperrverwaltung
    Original:
    Generic lock management
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    lock(C++11)
    try_lock(C++11)
    defer_lock
    try_to_lock
    adopt_lock    		(C++11)
    (C++11)
    (C++11)
    Zustand Variablen
    Original:
    Condition variables
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    condition_variable(C++11)
    condition_variable_any(C++11)
    notify_all_at_thread_exit(C++11)
    cv_status(C++11)
    Futures
    Original:
    Futures
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    promise(C++11)
    future(C++11)
    shared_future(C++11)
    packaged_task(C++11)
    async(C++11)
     
    definiert in Header <future>
    template<class Function, class... Args>

    std::future<typenamestd::result_of<Function(Args...)>::type>

        async( Function&& f, Args&&... args);
    		 (1) (seit C++11)
    template<class Function, class... Args>

    std::future<typenamestd::result_of<Function(Args...)>::type>

        async(std::launch policy, Function&& f, Args&&... args);
    		 (2) (seit C++11)
    Die Template-Funktion async führt die Funktion f asynchron (möglicherweise in einem separaten Thread) und gibt einen std::future, die schließlich halten wird das Ergebnis dieser Funktion Anruf .
    Original:
    The template function async runs the function f asynchronously (potentially in a separate thread) and returns a std::future that will eventually hold the result of that function call.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    1)
    Bewirkt das gleiche wie async(std::launch::async|std::launch::deferred, f, args...). Mit anderen Worten kann f in einem neuen Thread gestartet werden, oder sie kann synchron betrieben werden, wenn die resultierende std::future für einen Wert abgefragt wird .
    Original:
    Behaves the same as async(std::launch::async|std::launch::deferred, f, args...). In other words, f may be started in a new thread or it may be run synchronously when the resulting std::future is queried for a value.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    2)
    Ruft eine Funktion f mit Argumenten args nach einem bestimmten Start-Politik policy:
    Original:
    Calls a function f with arguments args according to a specific launch policy policy:
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    • 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.

    Inhaltsverzeichnis

    [Bearbeiten]Parameter

    f -
    Funktion oder Objekt zu nennen
    Original:
    function or function object to call
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    args... -
    Parameter, die an f passieren
    Original:
    parameters to pass to f
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    policy -
    Bitmaskenwert, wo einzelne Bits steuern die zulässigen Methoden der Ausführung
    Bit
    Erklärung
    Original:
    Explanation
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    std::launch::async
    ermöglichen asynchrone Auswertung
    Original:
    enable asynchronous evaluation
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    std::launch::deferred
    ermöglichen lazy evaluation
    Original:
    enable lazy evaluation
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Original:
    bitmask value, where individual bits control the allowed methods of execution
    Bit
    Erklärung
    Original:
    Explanation
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    std::launch::async
    ermöglichen asynchrone Auswertung
    Original:
    enable asynchronous evaluation
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    std::launch::deferred
    ermöglichen lazy evaluation
    Original:
    enable lazy evaluation
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    [Bearbeiten]Rückgabewert

    std::future bezogen auf den Rückgabewert der Funktion .
    Original:
    std::future referring to the return value of the function.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    [Bearbeiten]Ausnahmen

    Wirft std::system_error mit Fehlerbedingung std::errc::resource_unavailable_try_again wenn der Start Politik ist std::launch::async und die Umsetzung ist nicht in der Lage, einen neuen Thread starten .
    Original:
    Throws std::system_error with error condition std::errc::resource_unavailable_try_again if the launch policy is std::launch::async and the implementation is unable to start a new thread.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    [Bearbeiten]Notes

    Die Implementierung kann das Verhalten des ersten Überlastung std::async indem zusätzliche (Implementierung definiert) Bits in der Standard-Start-Politik erweitern .
    Original:
    The implementation may extend the behavior of the first overload of std::async by enabling additional (implementation-defined) bits in the default launch policy.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    [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)returnstd::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';}

    Output: 

    The sum is 10000
    Von „https://de.cppreference.com/mwiki/index.php?title=cpp/thread/async&oldid=31653“
    close