Meniu

Multithreading în C ++ cu exemple

multithreading c with examples

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

O scurtă introducere în Multithreading în C ++.

În acest tutorial, vom obține o prezentare generală a multithreading-ului în C ++.

Deci, ce este un fir? Un fir este o unitate de lucru a unui anumit proces. În sistemele de operare multi-programare, diferite procese se execută simultan.

În mod similar, este posibil să dorim să executăm aceleași instanțe de proces simultan. Fiecare instanță de proces, în acest caz, este alocată unei unități de execuție numită fir. Într-un sistem multithreading, numeroase fire se execută simultan independent unul de celălalt.

=> Consultați aici ghidul pentru începători C ++.

gateway implicit nu este disponibil Windows 10

MULTITHREADING ÎN C ++

Înainte de C ++ 11, aveam suport pentru firul POSIX. Dar această caracteristică avea probleme grave de portabilitate, deoarece funcționa numai pe sistemul de operare Linux sau UNIX. Astfel, începând cu C ++ 11, avem o singură clasă std :: thread care definește toate funcționalitățile pentru fire. Clasele și funcțiile sunt definite în fișierul antet.

Ce veți învăța:

De lucru

Folosind std :: thread, trebuie pur și simplu să creăm un nou obiect de tip thread și să-i dăm un apelabil. Un apelabil este un cod executabil pe care dorim să-l executăm când rulează firul. Deci, ori de câte ori dorim un fir nou, doar creăm un obiect std :: thread și trecem un apelabil ca argument către constructorul său.

Odată creat obiectul std :: thread, se lansează un nou thread și se execută codul furnizat de callable.

Să vedem cum putem defini un apelabil care să fie furnizat obiectului fir.

Un apelabil poate fi definit în trei moduri.

# 1) Utilizarea obiectului Function

Putem folosi un obiect funcțional ca apelabil în obiectul thread. Pentru utilizarea obiectului funcție, trebuie să avem o clasă și, în acea clasă, supraîncărcăm operatorul (). Această funcție supraîncărcată conține codul care trebuie executat la crearea firului.

/ / 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)

Rețineți modul în care este definit obiectul fir. Ca prim parametru pentru constructorul obiectului thread, oferim funcția supraîncărcată și apoi specificăm argumentele sale (params) ca al doilea argument.

# 2) Utilizarea indicatorului funcțional

Un pointer apelabil cu funcție poate fi definit în felul următor.

void funct_call(params) //code to be executed }

Odată ce definim această funcție, putem crea un obiect thread cu această funcție ca apelabil, în felul următor.

std::thread thread_obj(funct_call, params);

Rețineți că argumentele (params) transmise funcției sunt furnizate după numele funcției din obiectul thread.

# 3) Utilizarea unei expresii Lambda

Putem avea, de asemenea, o expresie apelabilă ca lambda și o putem transmite obiectului fir pentru executare. Fragmentul de cod pentru același lucru este prezentat mai jos.

// Define a lambda expression auto f = ()(params) { // code for execution }; std::thread thread_object(f, params);

În codul de mai sus, am definit o expresie lambda f și apoi o trecem la constructorul obiectului fir ca primul argument urmat de parametrii săi (params) ca al doilea argument.

std::thread join method

În unele cazuri, am putea dori ca firul de executare curent să se termine înainte de a începe o altă acțiune.

Un exemplu clasic este atunci când deschidem aplicația GUI. În momentul în care deschidem aplicația, se pornește un fir pentru încărcarea și inițializarea interfeței grafice și nu putem efectua nicio acțiune decât dacă încărcarea și inițializarea sunt efectuate corect, astfel încât să ne asigurăm că interfața grafică funcționează corect.

Clasa std :: thread furnizează o metodă join () care asigură că firul curent (indicat de * acest lucru) se termină mai întâi înainte de a fi luată orice altă acțiune.

Luați exemplul următor,

int main() { std::thread t1(callable_code); ….. t1.join(); ….. }

În exemplul de mai sus, funcția principală va trebui să aștepte pentru a continua până când firul t1 se termină. În general, funcția de asociere a firului blochează alte acțiuni / funcționalități până când apelul firului termină executarea.

Exemplu de fir

Vă prezentăm un exemplu complet de codare pentru crearea și execuția firului în programul prezentat mai jos.

#include #include using namespace std; // function to be used in callable void func_dummy(int N) { for (int i = 0; i

Ieșire:

Firul 1 :: apelabil => indicatorul funcției
Firul 1 :: apelabil => indicatorul funcției
Fir 3: apelabil => expresie lambda
Fir 3: apelabil => expresie lambda
Fir 2: apelabil => obiect funcție
Fir 2: apelabil => obiect funcție

În exemplul de mai sus, am creat trei fire utilizând trei apeluri diferite, adică pointer funcțional, obiect și expresie lambda. Creăm 2 instanțe din fiecare fir și le pornim. După cum se arată în ieșire, trei fire funcționează simultan independent unul de celălalt.

Citire recomandată = >> Ghid de testare a firului

Concluzie

În acest tutorial, am văzut conceptele multithreading în C ++ cu un exemplu clar. În tutorialele noastre ulterioare, vom învăța mai multe subiecte C ++ care ne-ar ajuta să scriem programe robuste și eficiente.

=> Citiți seria Easy C ++ Training.

Lectură recomandată

^