Motivazione: motivo per cui sto considerando che il mio geniale project manager pensa che la spinta sia un'altra dipendenza e che sia orribile perché "dipendi da essa" (ho provato a spiegare la qualità della spinta, poi ho rinunciato dopo qualche tempo :( La ragione più piccola per cui mi piacerebbe farlo è che vorrei imparare le funzionalità di c ++ 11, perché le persone inizieranno a scrivere codice in esso.

1. Esiste un mapping 1: 1 tra #include<thread> #include<mutex>e aumenta gli equivalenti?
2. Considereresti una buona idea sostituire gli elementi boost con elementi c ++ 11
   . Il mio utilizzo è primitivo, ma ci sono esempi in cui std non offre quale boost fa? O (blasfemia) viceversa?

PS Uso GCC, quindi ci sono le intestazioni.

Esistono diverse differenze tra Boost.Thread e la libreria di thread standard C ++ 11:

• Boost supporta la cancellazione dei thread, i thread C ++ 11 no
• C ++ 11 supporta std::async, ma Boost no
• Boost ha un boost::shared_mutexblocco per lettore multiplo / scrittore singolo. L'analogo std::shared_timed_mutexè disponibile solo dal C ++ 14 ( N3891 ), mentre std::shared_mutexè disponibile solo dal C ++ 17 ( N4508 ).
• I timeout C ++ 11 sono diversi dai timeout Boost (anche se questo dovrebbe presto cambiare ora Boost.Chrono è stato accettato).
• Alcuni nomi sono diversi (ad es. boost::unique_futureVs std::future)
• La semantica di passaggio degli argomenti di std::threadè diversa da boost::thread--- Boost utilizza boost::bind, il che richiede argomenti copiabili. std::threadconsente a tipi di solo spostamento come quelli std::unique_ptrdi essere passati come argomenti. A causa dell'uso di boost::bind, anche la semantica dei segnaposto, come _1nelle espressioni di bind nidificate, può essere diversa.
• Se non si chiama in modo esplicito join()o detach()il boost::threaddistruttore e l'operatore di assegnazione chiameranno detach()l'oggetto thread a cui viene distrutto / assegnato. Con un std::threadoggetto C ++ 11 , ciò comporterà una chiamata std::terminate()e l'interruzione dell'applicazione.

Per chiarire il punto sui parametri di solo spostamento, il seguente è C ++ 11 valido e trasferisce la proprietà del intdal temporaneo std::unique_ptral parametro di f1quando viene avviato il nuovo thread. Tuttavia, se lo si utilizza boost::thread, non funzionerà, poiché utilizza boost::bindinternamente e std::unique_ptrnon può essere copiato. C'è anche un bug nella libreria di thread C ++ 11 fornita con GCC che impedisce questo funzionamento, poiché lo utilizza anche std::bindnell'implementazione.

void f1(std::unique_ptr<int>);
std::thread t1(f1,std::unique_ptr<int>(new int(42)));

Se stai usando Boost, puoi probabilmente passare ai thread C ++ 11 in modo relativamente indolore se il tuo compilatore lo supporta (ad es. Versioni recenti di GCC su Linux hanno un'implementazione quasi completa della libreria di thread C ++ 11 disponibile in -std=c++0xmodalità).

Se il tuo compilatore non supporta i thread C ++ 11, potresti essere in grado di ottenere un'implementazione di terze parti come Just :: Thread , ma questa è ancora una dipendenza.

std::threadè in gran parte modellato dopo boost::thread, con alcune differenze :

• la semantica di boost di one-handle-maps-to-one-os-thread di boost non viene copiata. Ma questo thread è mobile per consentire il ritorno del thread dalle funzioni di fabbrica e il posizionamento in contenitori.
• Questa proposta aggiunge la cancellazione al boost::thread, che è una complicazione significativa. Questa modifica ha un grande impatto non solo sul thread ma anche sul resto della libreria di threading C ++. Si ritiene che questo grande cambiamento sia giustificabile a causa del vantaggio.
  • Il distruttore di thread ora deve chiamare Annulla prima del distacco per evitare perdite accidentali di thread figlio quando i thread padre vengono annullati.
  • È ora richiesto un membro di distacco esplicito per abilitare il distacco senza annullamento.
• I concetti di handle del thread e identità del thread sono stati separati in due classi (sono la stessa classe in boost::thread). Questo per supportare una più semplice manipolazione e memorizzazione dell'identità del thread.
• È stata aggiunta la possibilità di creare un ID thread garantito per un confronto uguale a nessun altro thread unibile ( boost::threadnon presente). Questo è utile per il codice che vuole sapere se viene eseguito dallo stesso thread di una chiamata precedente (i mutex ricorsivi sono un esempio concreto).
• Esiste una "backdoor" per ottenere l'handle del thread nativo in modo che i client possano manipolare i thread utilizzando il sistema operativo sottostante se lo si desidera.

È del 2007, quindi alcuni punti non sono più validi: boost::threadha una native_handlefunzione ora e, come sottolineano i commentatori, std::threadnon ha più la cancellazione.

Non sono riuscito a trovare differenze significative tra boost::mutexe std::mutex.

C'è un motivo per cui non migrare std::thread.

Se si utilizza il collegamento statico, std::threaddiventa inutilizzabile a causa di questi bug / funzionalità di gcc:

• http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52590
• http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57740

Vale a dire, se si chiama std::thread::detacho std::thread::joinporterà a un'eccezione o un arresto anomalo, mentre boost::threadin questi casi funziona bene.

Caso aziendale

Se stai scrivendo software per l'azienda che deve funzionare su una varietà da moderata a grande di sistemi operativi e di conseguenza costruire con una varietà di compilatori e versioni di compilatori (soprattutto quelli relativamente vecchi) su tali sistemi operativi, il mio suggerimento è di stare lontano da C ++ 11 per ora. Ciò significa che non è possibile utilizzare std::threade che consiglierei di utilizzare boost::thread.

Caso di avvio tecnico / di base

Se stai scrivendo per uno o due sistemi operativi, sai per certo che dovrai sempre costruire con un compilatore moderno che supporti principalmente C ++ 11 (ad esempio VS2015, GCC 5.3, Xcode 7), e non lo sei già dipende dalla libreria boost, quindi std::threadpotrebbe essere una buona opzione.

La mia esperienza

Sono personalmente parziale rispetto a biblioteche rinforzate, molto usate, altamente compatibili, altamente coerenti come boost contro un'alternativa molto moderna. Ciò è particolarmente vero per argomenti di programmazione complicati come il threading. Inoltre, ho sperimentato a lungo un grande successo con boost::thread(e boost in generale) in una vasta gamma di ambienti, compilatori, modelli di threading, ecc. Quando è la mia scelta, scelgo boost.

Con Visual Studio 2013 std::mutexsembra che si comporti in modo diverso rispetto a quello boost::mutex, che mi ha causato alcuni problemi (vedi questa domanda ).

Per quanto riguarda std :: shared_mutex aggiunto in C ++ 17

Le altre risposte qui forniscono un'ottima panoramica delle differenze in generale. Tuttavia, ci sono diversi problemi con std::shared_mutexquesto boost risolve.

1. Mici aggiornabili. Questi sono assenti da std::thread. Consentono a un lettore di essere aggiornato a uno scrittore senza consentire ad altri scrittori di entrare prima di te . Questi consentono di eseguire operazioni come pre-elaborare un calcolo di grandi dimensioni (ad esempio, reindicizzare una struttura di dati) in modalità lettura, quindi eseguire l'aggiornamento per scrivere per applicare il reindex mentre si tiene il blocco in scrittura solo per un breve periodo.

2. Equità. Se hai un'attività di lettura costante con a std::shared_mutex, i tuoi scrittori verranno bloccati indefinitamente. Questo perché se arriva un altro lettore, avranno sempre la priorità. Con boost:shared_mutex, alla fine verrà data priorità a tutti i thread . ⁽¹⁾ Né i lettori né gli scrittori saranno affamati.

Il tl; dr di questo è che se si dispone di un sistema con un throughput molto elevato senza tempi di inattività e contese molto elevate, std::shared_mutexnon funzionerà mai per te senza la creazione manuale di un sistema prioritario su di esso. boost::shared_mutexfunzionerà immediatamente, anche se in alcuni casi potrebbe essere necessario modificarlo. Direi che std::shared_mutexil comportamento è un bug latente in attesa di accadere nella maggior parte del codice che lo utilizza.

⁽¹⁾ _{L' attuale algoritmo che utilizza si basa sullo schedulatore del thread del sistema operativo. Nella mia esperienza, quando le letture sono sature, ci sono pause più lunghe (quando si ottiene un blocco in scrittura) su Windows che su OSX / Linux.}

Ho provato a usare shared_ptr da std invece di boost e in realtà ho trovato un bug nell'implementazione di gcc di questa classe. La mia applicazione stava andando in crash a causa del distruttore chiamato due volte (questa classe dovrebbe essere thread-safe e non dovrebbe generare tali problemi). Dopo essersi spostato su boost :: shared_ptr tutti i problemi sono scomparsi. Le attuali implementazioni di C ++ 11 non sono ancora mature.

Boost ha anche più funzionalità. Ad esempio, l'intestazione nella versione std non fornisce il serializzatore a uno stream (ovvero cout << duration). Boost ha molte librerie che usano i propri equivalenti, ecc., Ma non cooperano con le versioni standard.

Per riassumere: se hai già un'applicazione scritta usando boost, è più sicuro mantenere il tuo codice così com'è invece di fare qualche sforzo per passare allo standard C ++ 11.