multithreading c with examples
Una breve introduzione al multithreading in C ++.
In questo tutorial, avremo una panoramica del multithreading in C ++.
Allora cos'è un thread? Un thread è un'unità di lavoro di un particolare processo. Nei sistemi operativi multi-programmazione, diversi processi vengono eseguiti simultaneamente.
In modo simile, potremmo voler eseguire le stesse istanze di processo contemporaneamente. Ogni istanza di processo, in questo caso, è assegnata a un'unità di esecuzione chiamata thread. In un sistema multithreading, numerosi thread vengono eseguiti contemporaneamente indipendentemente l'uno dall'altro.
=> Dai un'occhiata alla Guida per principianti di C ++ qui.
come risolvere l'eccezione dell'indice di matrice fuori dai limiti in java
Prima di C ++ 11, avevamo il supporto per i thread POSIX. Ma questa caratteristica aveva seri problemi di portabilità poiché funzionava solo sul sistema operativo Linux o UNIX. Quindi da C ++ 11 in poi, abbiamo una sola classe std :: thread che definisce tutte le funzionalità per i thread. Le classi e le funzioni sono definite nel file di intestazione.
Cosa imparerai:
Lavorando di
Usando std :: thread dobbiamo semplicemente creare un nuovo oggetto thread e passargli un callable. Un callable è un codice eseguibile che vogliamo eseguire quando il thread è in esecuzione. Quindi, ogni volta che vogliamo un nuovo thread, creiamo semplicemente un oggetto di std :: thread e passiamo un callable come argomento al suo costruttore.
Una volta creato l'oggetto std :: thread, viene avviato un nuovo thread e viene eseguito il codice fornito da callable.
Vediamo come possiamo definire un callable da fornire all'oggetto thread.
Un callable può essere definito in tre modi.
# 1) Utilizzo dell'oggetto funzione
Possiamo usare un oggetto funzione come richiamabile nell'oggetto thread. Per usare l'oggetto funzione, dobbiamo avere una classe e in quella classe sovraccarichiamo l'operatore (). Questa funzione sovraccarica contiene il codice da eseguire quando viene creato il thread.
piano di test di esempio per il test del software
/ / Define the class for function object class functioObject_class { // Overload () operator void operator()(params) { // code to be executed } }; // Create thread object
std::thread thread_object(functioObject_class (), params)
Nota il modo in cui viene definito l'oggetto thread. Come primo parametro del costruttore dell'oggetto thread, forniamo la funzione sovraccaricata e quindi specifichiamo i suoi argomenti (params) come secondo argomento.
# 2) Utilizzo del puntatore a funzione
Un puntatore a funzione richiamabile utilizzando può essere definito nel modo seguente.
void funct_call(params) //code to be executed }
Una volta definita questa funzione, possiamo creare un oggetto thread con questa funzione come richiamabile, nel modo seguente.
std::thread thread_obj(funct_call, params);
Notare che gli argomenti (parametri) passati alla funzione, vengono forniti dopo il nome della funzione nell'oggetto thread.
# 3) Utilizzo di un'espressione Lambda
Possiamo anche avere un callable come espressione lambda e passarlo all'oggetto thread per l'esecuzione. Lo snippet di codice per lo stesso è mostrato di seguito.
// Define a lambda expression auto f = [](params) { // code for execution };
std::thread thread_object(f, params);
Nel codice precedente, abbiamo definito un'espressione lambda f e quindi la passiamo al costruttore dell'oggetto thread come primo argomento seguito dai suoi parametri (params) come secondo argomento.
std::thread join method
In alcuni casi, potremmo volere che il thread attualmente in esecuzione finisca prima di iniziare un'altra azione.
Un classico esempio è quando apriamo l'applicazione GUI. Nel momento in cui apriamo l'applicazione, viene avviato un thread per caricare e inizializzare la GUI e non possiamo eseguire alcuna azione a meno che il caricamento e l'inizializzazione non siano eseguiti correttamente in modo da garantire che la GUI funzioni correttamente.
La classe std :: thread fornisce un metodo join () che assicura che il thread corrente (indicato da * this) termini prima prima che venga intrapresa qualsiasi altra azione.
Prendiamo il seguente esempio,
int main() { std::thread t1(callable_code); ….. t1.join(); ….. }
Nell'esempio precedente, la funzione main dovrà attendere per continuare fino al termine del thread t1. In generale, la funzione join del thread blocca altre azioni / funzionalità fino a quando il thread chiamante non termina la sua esecuzione.
Esempio di filo
Presentiamo un esempio di codifica completo per la creazione e l'esecuzione del thread nel programma mostrato di seguito.
#include #include using namespace std; // function to be used in callable void func_dummy(int N) { for (int i = 0; i Produzione:
Thread 1 :: callable => puntatore a funzione
Thread 1 :: callable => puntatore a funzione
Thread 3 :: callable => espressione lambda
Thread 3 :: callable => espressione lambda
Thread 2 :: callable => oggetto funzione
Thread 2 :: callable => oggetto funzione
Nell'esempio precedente, abbiamo creato tre thread utilizzando tre diversi callable, ovvero puntatore a funzione, oggetto ed espressione lambda. Creiamo 2 istanze di ogni thread e le avviamo. Come mostrato nell'output, tre thread funzionano contemporaneamente indipendentemente l'uno dall'altro.
Lettura consigliata = >> Guida al test del filo
it help desk intervista domande e risposte pdf
Conclusione
In questo tutorial, abbiamo visto i concetti di multithreading in C ++ con un chiaro esempio. Nei nostri tutorial successivi, impareremo altri argomenti C ++ che ci aiuterebbero a scrivere programmi robusti ed efficienti.
=> Leggere la serie di formazione Easy C ++.
Lettura consigliata
- Tutorial sulle funzioni principali di Python con esempi pratici
- Tutorial Python DateTime con esempi
- Comando Taglia in Unix con esempi
- Sintassi dei comandi Cat Unix, opzioni con esempi
- Utilizzo del cursore in MongoDB con esempi
- Comando Ls in Unix con esempi
- Metodo MongoDB Sort () con esempi
- Comando Grep in Unix con semplici esempi