Il multithreading in C++ è una funzionalità che consente di eseguire più attività contemporaneamente in concomitanza. Un thread è l'unità di lavoro di un particolare processo in esecuzione. Numerosi thread vengono eseguiti indipendentemente l'uno dall'altro contemporaneamente per eseguire il multithreading.
Come implementare il multithreading in C++
Un programma multithread è composto da due o più parti che tendono a essere eseguite simultaneamente, ciascuna parte è nota come thread e ha un percorso diverso per l'esecuzione. Numerosi thread vengono eseguiti indipendentemente l'uno dall'altro contemporaneamente per eseguire il multithreading.
Prerequisiti per il multithreading in C++
In Windows, le funzioni relative ai thread possono essere eseguite in C++ 11 e versioni avanzate. Durante l'utilizzo del compilatore Dev-C++, per impostazione predefinita si trova nella versione C++ 3, quindi è necessario modificarlo manualmente nella versione C++ 11. L'ambiente GNU C++11 può essere selezionato modificando le impostazioni standard della lingua.
Apri il compilatore Dev-C++ e vai su 'Strumenti' nella barra delle applicazioni. Selezionare 'Opzioni compilatore' e quindi selezionare 'Impostazioni', fare clic sul blocco 'Generazione codice' verrà visualizzato un elenco dei comandi. Selezionare GNU C++11 da 'Language Standard(-std)' e quindi fare clic su OK. Ora questo compilatore è pronto per supportare le operazioni sui thread.
Scarica le librerie da GitHub e inserirli nella cartella lib del compilatore Cpp. Chiama queste librerie nel programma usando #include 'mingw.thread.h' e i file header
std::thread oggetto_thread ( richiamabile ) ;
Il std::thread è supportato dal file di intestazione #include 'mingw.thread.h' in C++11. È una classe thread e rappresenta un singolo thread. Viene creato un nuovo thread utilizzando std::thread e gli viene passato un callable. Callable è un codice eseguibile, che viene eseguito quando viene eseguito il thread. Il richiamabile può essere uno qualsiasi dei tre tipi indicati di seguito:
Quando viene creato un oggetto, lancia un nuovo thread, che esegue il codice nel callable.
Lancio del thread utilizzando l'oggetto funzione
Un oggetto funzione può essere utilizzato come richiamabile per avviare il thread, l'operatore di sovraccarico () lo rende richiamabile:
classe funzione_oggetto_class {operatore vuoto ( ) ( parametri )
{
Dichiarazioni;
}
}
std::thread oggetto_thread ( funzione_oggetto_class ( ) , parametri )
La funzione di sovraccarico viene fornita al costruttore come primo oggetto e alle istruzioni come secondo oggetto.
Lancio del thread utilizzando Function Pointer
Viene definito un puntatore a funzione che viene quindi utilizzato come richiamabile per avviare un thread:
funzione_chiamata nulla ( param ){
Dichiarazioni;
}
std::thread thread_obj ( chiamata_funzione, param ) ;
Gli argomenti da passare vengono scritti dopo il nome della funzione.
Lancio di Thread utilizzando Lambda Expression
L'oggetto thread può essere avviato utilizzando lambda come richiamabile.
// Definire un'espressione lambdaauto f = [ ] ( parametri )
{
Dichiarazioni;
} ;
std::thread oggetto_thread ( f, parametri ) ;
L'espressione lambda è definita e i parametri vengono chiamati al suo interno per avviare il thread.
In alcuni casi, il thread deve interrompersi prima di iniziare a eseguire il comando successivo. IL std::thread::join () la funzione viene utilizzata per attendere la fine del thread. Ad esempio, nel caso in cui assegniamo un'attività di GUI al thread, dobbiamo prima attendere il momento della fine per caricare correttamente la GUI e poi avrà luogo l'esecuzione del comando successivo.
int principale ( ){
std::thread t1 ( richiamabile ) ;
t1.join ( ) ;
Dichiarazioni;
}
Esempio
Questo è un programma che viene eseguito per eseguire il multithreading utilizzando tutti e tre i richiamabili. Tre diversi chiamabili eseguono i rispettivi comandi contemporaneamente per tre volte senza essere interrotti l'uno dall'altro:
#include#include
utilizzando lo spazio dei nomi std;
vuoto foo ( int Z )
{
per ( int io = 0 ; io < Z; i++ ) {
cout << 'Discussione utilizzando la funzione'
' puntatore come richiamabile \N ' ;
}
}
classe thread_oggetto {
pubblico:
operatore vuoto ( ) ( intero x )
{
per ( int io = 0 ; io < X; i++ )
cout << 'Discussione utilizzando la funzione'
'oggetto come richiamabile \N ' ;
}
} ;
// codice principale
int principale ( )
{
cout << 'Discussioni 1, 2 e 3'
'operante in modo indipendente'
<< fine;
discussione th1 ( pippo, 3 ) ;
discussione th2 ( thread_obj ( ) , 3 ) ;
auto f = [ ] ( intero x ) {
per ( int io = 0 ; io < X; i++ )
cout << 'Thread utilizzando lambda'
' espressione come richiamabile \N ' ;
} ;
discussione th3 ( F, 3 ) ;
th1.join ( ) ;
th2.join ( ) ;
th3.join ( ) ;
ritorno 0 ;
}
In questo programma i tre richiamabili, inclusi il puntatore a funzione, l'oggetto funzione e l'espressione lambda, vengono utilizzati per avviare i tre thread contemporaneamente. I thread 1, 2 e 3 stampano i loro valori contemporaneamente, indipendentemente l'uno dall'altro, senza essere interrotti l'uno dall'altro. Stampano i loro valori tre volte. La funzione join() viene utilizzata per attendere la fine del thread.
Gli output di tutti e tre i thread vengono visualizzati in modo indipendente e ripetuti tre volte. Ogni thread attende che l'altro finisca prima.
Conclusione
Il multithreading in C++ è una funzionalità che consente di eseguire più attività contemporaneamente in concomitanza. Il programma multithread ha due o più sezioni che possono essere eseguite simultaneamente, ciascuna parte è nota come thread e ha un percorso separato per l'esecuzione. Sono disponibili tre chiamate per avviare thread, puntatori a funzione, oggetti funzione ed espressioni lambda. Questi abilitano il multithreading.