fork () vs std :: async in C ++

Question

Sono nuovo ai concetti di asyc e fork, quello che ho capito fino ad ora è che fork () crea processi chid che verranno eseguiti in modo asincrono. E std :: async creerà un thread dal pool di sistema e lo avvierà in modo asincrono qui se menziono std :: launch :: async .

Ad esempio, come differisce il set di codice sottostante? 1: utilizzo di std :: async

std::vector<std::future<void>> result;
for(i=0;i<5;i++){
    result. push_back(std::async(std::launch::asyc, foo, var1));
}

for( auto e : result) 
    e.get();

2 °: utilizzo di fork ()

for(i=0;i<5;i++){ 
    if(fork()==0){
        foo(var1);
        exit(0);
    }
}

Supponiamo che il tipo restituito dalla funzione foo sia void e che gli argomenti vengano passati come riferimento o puntatori.

Answer 1

La differenza fondamentale è che, nel caso di std::async, i due thread di esecuzione condividono un processo. Nel caso di fork, ognuno ha il proprio processo.

Questa differenza influisce in modo più significativo sulle cose che cambiano dopo la chiamata. Nel caso di fork, ogni processo può quindi aprire e chiudere i propri descrittori di file, gestire il proprio spazio di memoria e così via. Nel caso di std::async, i thread continuano a condividere descrittori di file, spazio di memoria e così via.

Answer 2

fork()

fork()crea un processo figlio duplicando il processo chiamante. Il processo figlio è scollegato dal processo genitore in modo che ognuno abbia la propria memoria e senza impostare alcun canale di comunicazione tra processi è impossibile passare i dati tra i due processi. Il caso d'uso più comune per la chiamata fork()è l'avvio di un processo come servizio in background (noto anche come "demone"). Ad esempio, quando avvii il tuo server web preferito sulla riga di comando, potrebbe eseguire il fork di un processo figlio (il processo del server effettivo). Una volta fatto, il processo principale termina, quindi il controllo torna alla shell e puoi fare altre cose.

std::async

std::asyncesegue una funzione in un thread separato (assumendo la politica std::launch::async). Restituisce un std::futuresu cui è possibile chiamare get()per ottenere il valore restituito dalla funzione (assumendo che sia restituito e non abbia generato un'eccezione). La get()chiamata ritorna immediatamente se la funzione è stata completata nel frattempo, altrimenti si blocca fino al ritorno della funzione. Questa caratteristica rende std::asyncuno strumento utile per eseguire calcoli costosi in background mentre si fa qualcos'altro.