Multithreading är en funktion som tillåter samtidig exekvering av två eller flera delar av ett program för maximalt utnyttjande av CPU:n. Varje del av ett sådant program kallas en tråd. Så trådar är lätta processer inom en process.
innehåller java-metoden
Multithreading-stöd introducerades i C++11. Före C++11 var vi tvungna att använda POSIX-trådar eller bibliotek . Även om det här biblioteket gjorde jobbet orsakade bristen på standardfunktioner som tillhandahålls av språket allvarliga portabilitetsproblem. C++ 11 gjorde bort allt det och gav oss std::tråd . Trådklasserna och relaterade funktioner definieras i header-fil.
Syntax:
std::thread thread_object (callable);>
std::tråd är trådklassen som representerar en enda tråd i C++. För att starta en tråd behöver vi helt enkelt skapa ett nytt trådobjekt och skicka exekveringskoden som ska anropas (dvs ett anropsbart objekt) till objektets konstruktor. När objektet har skapats startas en ny tråd som kommer att exekvera koden som anges i callable. En anropsbar kan vara vilken som helst av de fem:
- En funktionspekare
- Ett lambdauttryck
- Ett funktionsobjekt
- Icke-statisk medlemsfunktion
- Statisk medlemsfunktion
Efter att ha definierat den anropbara skickar vi den till konstruktören.
Starta tråd med funktionspekaren
En funktionspekare kan vara ett anropsbart objekt att skicka till std::thread-konstruktorn för att initiera en tråd. Följande kodavsnitt visar hur det görs.
Exempel:
C++
void> foo(param)> {> >Statements;> }> // The parameters to the function are put after the comma> std::>thread> thread_obj(foo, params);> |
>
>
Starta tråd med Lambda Expression
std::thread-objekt kan också startas med ett lambda-uttryck som anropsbart. Följande kodavsnitt visar hur detta görs:
Exempel:
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);> |
centos vs rhel
>
>
Starta tråd med hjälp av funktionsobjekt
Funktionsobjekt eller funktioner kan också användas för att starta en tråd i C++. Följande kodavsnitt visar hur det går till:
Exempel:
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)> |
>
>
Notera : Vi skickar alltid parametrar för den anropbara separat som argument till trådkonstruktorn.
Startar tråd med hjälp av icke-statisk medlemsfunktion
Vi kan också starta tråden med den icke-statiska medlemsfunktionen i en klass. Följande utdrag visar hur man gör.
C++
// 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);> |
>
android.process.acore stannar hela tiden
>
Starta tråd med statisk medlemsfunktion
Vi kan också starta trådarna med hjälp av statiska 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);> |
>
jframe
>
Väntar på att trådarna ska sluta
När en tråd har startat kan vi behöva vänta på att tråden ska avslutas innan vi kan vidta några åtgärder. Om vi till exempel allokerar uppgiften att initiera GUI för en applikation till en tråd, måste vi vänta på att tråden ska avslutas för att säkerställa att GUI har laddats ordentligt.
För att vänta på en tråd, använd std::tråd::join() fungera. Denna funktion gör att den aktuella tråden väntar tills tråden identifieras av *detta har slutförts.
Till exempel, för att blockera huvudtråden tills tråden t1 är klar skulle vi göra:
C++
konvertera en sträng till heltal i java
int> main()> {> >// Start thread t1> >std::>thread> t1(callable);> >// Wait for t1 to finish> >t1.join();> >// t1 has finished do other stuff> >Statements;> }> |
>
>
Ett komplett C++-program för multitrådning
Ett C++-program ges nedan. Den startar tre trådar från huvudfunktionen. Varje tråd anropas med ett av de anropsbara objekten som anges ovan.
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; }> |
>
>
Utgång (maskinberoende)
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>
Notera: För att kompilera program med std::thread-stöd använd g++ -std=c++11 -pthread.