Eine Funktion parallel aufrufen C++

Question

Ich möchte eine Funktion in C++ parallel aufrufen, die einige Zeit wartet und einige Aufgaben ausführt. Aber ich möchte nicht, dass der Ausführungsfluss auf die Funktion wartet. Ich dachte über die Verwendung von Pthread auf einfache Weise nach, aber ich muss wieder warten bis es wieder da ist!

void A_Function() 
{ 
/* Call a function which waits for some time and then perform some tasks */ 

/* Do not wait for the above function to return and continue performing the background tasks */ 
} 

Hinweis: Wenn ich die Funktion parallel dann im nächsten Zyklus nicht die Hintergrundaufgaben ausführen, während Aufruf, wird die Funktion mir nicht korrekte Ausgabe geben.

Vielen Dank im Voraus.

Answer 1

Verwenden Sie eine std::future, um eine std::async Aufgabe zu packen. Warten Sie auf die Zukunft an der Spitze Ihrer Funktion, um sicherzustellen, dass sie vor der nächsten Iteration abgeschlossen ist, da Sie angegeben haben, dass die nächste Iteration von der Ausführung dieser Hintergrundaufgabe abhängt.

Im folgenden Beispiel mache ich die Hintergrundaufgabe zu einem einfachen atomaren Inkrement eines Zählers, und die Vordergrundaufgabe gibt nur den Zählerwert zurück. Dies dient nur zur Veranschaulichung!

#include <iostream> 
#include <future> 
#include <thread> 

class Foo { 
public: 
    Foo() : counter_(0) {} 

    std::pair<int, std::future<void>> a_function(std::future<void>& f) { 
     // Ensure that the background task from the previous iteration 
     // has completed 
     f.wait(); 

     // Set the task for the next iteration 
     std::future<void> fut = std::async(std::launch::async, 
             &Foo::background_task, this); 

     // Do some work 
     int value = counter_.load(); 

     // Return the result and the future for the next iteration 
     return std::make_pair(value, std::move(fut)); 
    } 

    void background_task() { 
     ++counter_; 
    } 

private: 
    std::atomic<int> counter_; 
}; 

int main() { 
    // Bootstrap the procedure with some empty task... 
    std::future<void> bleak = std::async(std::launch::deferred, [](){}); 

    Foo foo; 

    // Iterate... 
    for (size_t i = 0; i < 10; ++i) { 
     // Call the function 
     std::pair<int, std::future<void>> result = foo.a_function(bleak); 
     // Set the future for the next iteration 
     bleak = std::move(result.second); 

     // Do something with the result 
     std::cout << result.first << "\n"; 
    } 
} 

Live example