C++
Futures e promesse
Ricerca…
introduzione
Promesse e Futures vengono utilizzati per traghettare un singolo oggetto da un thread all'altro.
Un oggetto std::promise
è impostato dal thread che genera il risultato.
Un oggetto std::future
può essere utilizzato per recuperare un valore, per verificare se un valore è disponibile o per interrompere l'esecuzione fino a quando il valore non è disponibile.
std :: future e std :: promise
L'esempio seguente imposta una promessa per essere utilizzata da un altro thread:
{
auto promise = std::promise<std::string>();
auto producer = std::thread([&]
{
promise.set_value("Hello World");
});
auto future = promise.get_future();
auto consumer = std::thread([&]
{
std::cout << future.get();
});
producer.join();
consumer.join();
}
Esempio asincrono rinviato
Questo codice implementa una versione di std::async
, ma si comporta come se async
venisse sempre chiamato con il criterio di avvio deferred
. Questa funzione inoltre non ha lo speciale comportamento future
async
; il future
restituito può essere distrutto senza mai acquisire il suo valore.
template<typename F>
auto async_deferred(F&& func) -> std::future<decltype(func())>
{
using result_type = decltype(func());
auto promise = std::promise<result_type>();
auto future = promise.get_future();
std::thread(std::bind([=](std::promise<result_type>& promise)
{
try
{
promise.set_value(func());
// Note: Will not work with std::promise<void>. Needs some meta-template programming which is out of scope for this example.
}
catch(...)
{
promise.set_exception(std::current_exception());
}
}, std::move(promise))).detach();
return future;
}
std :: packaged_task e std :: future
std::packaged_task
raggruppa una funzione e la promessa associata per il suo tipo di ritorno:
template<typename F>
auto async_deferred(F&& func) -> std::future<decltype(func())>
{
auto task = std::packaged_task<decltype(func())()>(std::forward<F>(func));
auto future = task.get_future();
std::thread(std::move(task)).detach();
return std::move(future);
}
Il thread inizia a correre immediatamente. Possiamo staccarlo o unirlo alla fine dello scope. Quando termina la chiamata alla funzione std :: thread, il risultato è pronto.
Si noti che questo è leggermente diverso da std::async
dove lo std::future
restituito quando viene distrutto in realtà bloccherà fino al termine del thread.
std :: future_error e std :: future_errc
Se non vengono soddisfatti i vincoli per std :: promise e std :: future non viene generata un'eccezione di tipo std :: future_error.
Il membro del codice di errore nell'eccezione è di tipo std :: future_errc e i valori sono i seguenti, insieme ad alcuni casi di test:
enum class future_errc {
broken_promise = /* the task is no longer shared */,
future_already_retrieved = /* the answer was already retrieved */,
promise_already_satisfied = /* the answer was stored already */,
no_state = /* access to a promise in non-shared state */
};
Promessa non attiva:
int test()
{
std::promise<int> pr;
return 0; // returns ok
}
Promessa attiva, non utilizzata:
int test()
{
std::promise<int> pr;
auto fut = pr.get_future(); //blocks indefinitely!
return 0;
}
Doppio recupero:
int test()
{
std::promise<int> pr;
auto fut1 = pr.get_future();
try{
auto fut2 = pr.get_future(); // second attempt to get future
return 0;
}
catch(const std::future_error& e)
{
cout << e.what() << endl; // Error: "The future has already been retrieved from the promise or packaged_task."
return -1;
}
return fut2.get();
}
Impostazione di std :: promise value due volte:
int test()
{
std::promise<int> pr;
auto fut = pr.get_future();
try{
std::promise<int> pr2(std::move(pr));
pr2.set_value(10);
pr2.set_value(10); // second attempt to set promise throws exception
}
catch(const std::future_error& e)
{
cout << e.what() << endl; // Error: "The state of the promise has already been set."
return -1;
}
return fut.get();
}
std :: future e std :: async
Nel seguente esempio di naie parallelo sort sort, std::async
viene utilizzato per avviare più attività parallele merge_sort. std::future
è usato per aspettare i risultati e sincronizzarli:
#include <iostream>
using namespace std;
void merge(int low,int mid,int high, vector<int>&num)
{
vector<int> copy(num.size());
int h,i,j,k;
h=low;
i=low;
j=mid+1;
while((h<=mid)&&(j<=high))
{
if(num[h]<=num[j])
{
copy[i]=num[h];
h++;
}
else
{
copy[i]=num[j];
j++;
}
i++;
}
if(h>mid)
{
for(k=j;k<=high;k++)
{
copy[i]=num[k];
i++;
}
}
else
{
for(k=h;k<=mid;k++)
{
copy[i]=num[k];
i++;
}
}
for(k=low;k<=high;k++)
swap(num[k],copy[k]);
}
void merge_sort(int low,int high,vector<int>& num)
{
int mid;
if(low<high)
{
mid = low + (high-low)/2;
auto future1 = std::async(std::launch::deferred,[&]()
{
merge_sort(low,mid,num);
});
auto future2 = std::async(std::launch::deferred, [&]()
{
merge_sort(mid+1,high,num) ;
});
future1.get();
future2.get();
merge(low,mid,high,num);
}
}
Nota: nell'esempio std::async
viene avviato con policy std::launch_deferred
. Questo per evitare che un nuovo thread venga creato in ogni chiamata. Nel caso del nostro esempio, le chiamate a std::async
sono fatte fuori ordine, si sincronizzano alle chiamate per std::future::get()
.
std::launch_async
forza la std::launch_async
un nuovo thread in ogni chiamata.
La politica di default è std::launch::deferred| std::launch::async
, ovvero l'implementazione determina la politica per la creazione di nuovi thread.
Classi di operazioni asincrone
- std :: async: esegue un'operazione asincrona.
- std :: future: fornisce l'accesso al risultato di un'operazione asincrona.
- std :: promise: pacchetti il risultato di un'operazione asincrona.
- std :: packaged_task: raggruppa una funzione e la promessa associata per il suo tipo di ritorno.