Multithreading er en funktion, der tillader samtidig udførelse af to eller flere dele af et program for maksimal udnyttelse af CPU'en. Hver del af et sådant program kaldes en tråd. Så tråde er lette processer i en proces.
til streng metode java
Multithreading-understøttelse blev introduceret i C++11. Før C++11 skulle vi bruge POSIX-tråde eller bibliotek . Mens dette bibliotek gjorde jobbet, forårsagede manglen på et standardsprog-leveret funktionssæt alvorlige portabilitetsproblemer. C++ 11 gjorde op med alt det og gav os std::tråd . Trådklasserne og relaterede funktioner er defineret i header-fil.
Syntaks:
std::thread thread_object (callable);>
std::tråd er trådklassen, der repræsenterer en enkelt tråd i C++. For at starte en tråd skal vi blot oprette et nyt trådobjekt og sende den eksekverende kode, der skal kaldes (dvs. et kaldbart objekt) ind i objektets konstruktør. Når objektet er oprettet, startes en ny tråd, som vil udføre koden specificeret i callable. En callable kan være en af de fem:
- En funktionsmarkør
- Et Lambda-udtryk
- Et funktionsobjekt
- Ikke-statisk medlemsfunktion
- Statisk medlemsfunktion
Efter at have defineret den callable, videregiver vi den til konstruktøren.
Start af tråd ved hjælp af funktionsmarkør
En funktionsmarkør kan være et kaldbart objekt, der skal sendes til std::thread-konstruktøren til initialisering af en tråd. Følgende kodestykke viser, hvordan det gøres.
Eksempel:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Lancering af tråd ved hjælp af Lambda Expression
std::thread-objekt kan også startes ved at bruge et lambda-udtryk som callable. Følgende kodestykke viser, hvordan dette gøres:
Eksempel:
C++
// Define a lambda expression> auto> f = [](params)> {> >Statements;> };> // Pass f and its parameters to thread> // object constructor as> std::>thread> thread_object(f, params);> |
>
>
Start af tråd ved hjælp af funktionsobjekter
Funktionsobjekter eller -funktioner kan også bruges til at starte en tråd i C++. Følgende kodestykke viser, hvordan det gøres:
Eksempel:
hvad gør en pc hurtig
C++
// Define the class of function object> class> fn_object_class {> >// Overload () operator> >void> operator()(params)> >{> >Statements;> >}> }> // Create thread object> std::>thread> thread_object(fn_object_class(), params)> |
>
>
Bemærk : Vi sender altid parametre for den callable separat som argumenter til trådkonstruktøren.
Lancering af tråd ved hjælp af ikke-statisk medlemsfunktion
Vi kan også starte tråden ved at bruge den ikke-statiske medlemsfunktion i en klasse. Følgende uddrag viser, hvordan du gør det.
C++
softwaretest og typer
// defining clasc> class> Base {> public>:> >// non-static member function> >void> foo(param) { Statements; }> }> // object of Base Class> Base b;> // first parameter is the reference to the functionn> // and second paramter is reference of the object> // at last we have arguments> std::>thread> thread_obj(&Base::foo, &b, params);> |
>
>
Starter tråd ved hjælp af statisk medlemsfunktion
Vi kan også starte trådene ved hjælp af statiske medlemsfunktioner.
C++
// defining class> class> Base {> public>:> >// static member function> >static> void> foo(param) { Statements; }> }> // object of Base Class> Base b;> // first parameter is the reference to the function> // and rest are arguments> std::>thread> thread_obj(&Base::foo, params);> |
>
softwaretest og typer
>
Venter på at tråde slutter
Når en tråd er startet, skal vi muligvis vente på, at tråden slutter, før vi kan foretage os noget. For eksempel, hvis vi tildeler opgaven med at initialisere GUI'en af en applikation til en tråd, skal vi vente på, at tråden slutter for at sikre, at GUI'en er indlæst korrekt.
For at vente på en tråd, brug std::tråd::join() fungere. Denne funktion får den aktuelle tråd til at vente, indtil tråden identificeres af *det her er færdig med at udføre.
For eksempel, for at blokere hovedtråden, indtil tråd t1 er færdig, ville vi gøre:
C++
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Et komplet C++-program til multithreading
Et C++ program er angivet nedenfor. Den starter tre tråde fra hovedfunktionen. Hver tråd kaldes ved hjælp af et af de kaldbare objekter specificeret ovenfor.
hvordan man fjerner det første tegn i excel
C++
// C++ program to demonstrate> // multithreading using three> // different callables.> #include> #include> using> namespace> std;> // A dummy function> void> foo(>int> Z)> {> >for> (>int> i = 0; i cout << 'Thread using function' ' pointer as callable
'; } } // A callable object class thread_obj { public: void operator()(int x) { for (int i = 0; i cout << 'Thread using function' ' object as callable
'; } }; // class definition class Base { public: // non-static member function void foo() { cout << 'Thread using non-static member function ' 'as callable' << endl; } // static member function static void foo1() { cout << 'Thread using static member function as ' 'callable' << endl; } }; // Driver code int main() { cout << 'Threads 1 and 2 and 3 ' 'operating independently' << endl; // This thread is launched by using // function pointer as callable thread th1(foo, 3); // This thread is launched by using // function object as callable thread th2(thread_obj(), 3); // Define a Lambda Expression auto f = [](int x) { for (int i = 0; i cout << 'Thread using lambda' ' expression as callable
'; }; // This thread is launched by using // lambda expression as callable thread th3(f, 3); // object of Base Class Base b; thread th4(&Base::foo, &b); thread th5(&Base::foo1); // Wait for the threads to finish // Wait for thread t1 to finish th1.join(); // Wait for thread t2 to finish th2.join(); // Wait for thread t3 to finish th3.join(); // Wait for thread t4 to finish th4.join(); // Wait for thread t5 to finish th5.join(); return 0; }> |
>
>
Output (maskineafhængig)
Threads 1 and 2 and 3 operating independently Thread using function pointer as callable Thread using function pointer as callable Thread using function pointer as callable Thread using non-static member function as callable Thread using function object as callable Thread using function object as callable Thread using function object as callable Thread using lambda expression as callable Thread using lambda expression as callable Thread using lambda expression as callable Thread using static member function as callable>
Bemærk: For at kompilere programmer med std::thread support, brug g++ -std=c++11 -pthread.