Ang multithreading sa C++ ay isang tampok na nagbibigay-daan sa isa na magsagawa ng maraming gawain nang sabay-sabay nang sabay-sabay. Ang thread ay ang working unit ng isang partikular na proseso na isinasagawa. Maraming mga thread ang nag-e-execute nang hiwalay sa isa't isa nang sabay-sabay upang magsagawa ng multithreading.
Paano Magpapatupad ng Multithreading sa C++
Ang isang multithread program ay may dalawa o higit pang mga bahagi na may posibilidad na tumakbo nang sabay-sabay, ang bawat bahagi ay kilala bilang isang thread at may ibang landas para sa pagpapatupad. Maraming mga thread ang nag-e-execute nang hiwalay sa isa't isa nang sabay-sabay upang magsagawa ng multithreading.
Pre-requisites para sa Multithreading sa C++
Sa Windows, ang mga function na nauugnay sa mga thread ay maaaring gawin sa C++ 11 at mga advanced na bersyon. Habang ginagamit ang Dev-C++ compiler, bilang default ito ay nasa C++ 3 na bersyon, kaya kailangan itong baguhin nang manu-mano sa C++ 11 na bersyon. Ang GNU C++11 na kapaligiran ay maaaring mapili sa pamamagitan ng pagbabago ng mga karaniwang setting ng wika.
Buksan ang Dev-C++ compiler at pumunta sa “Tools” sa taskbar. Piliin ang 'Mga Pagpipilian sa Compiler' at pagkatapos ay piliin ang 'Mga Setting', mag-click sa block na 'Pagbuo ng Code' isang listahan ng mga utos ang lilitaw. Piliin ang GNU C++11 mula sa “Language Standard(-std)” at pagkatapos ay i-click ang OK. Ngayon ang compiler na ito ay handa na upang suportahan ang mga pagpapatakbo ng thread.
I-download ang mga aklatan mula sa GitHub at ilagay ang mga ito sa lib folder ng Cpp compiler. Tawagan ang mga library na ito sa program gamit ang #include “mingw.thread.h” at
std::thread thread_object ( matatawag ) ;
Ang std::thread ay sinusuportahan ng #include “mingw.thread.h” header file sa C++11. Ito ay isang thread class at kumakatawan sa isang solong thread. Ang isang bagong thread ay nilikha gamit ang std::thread at isang callable ay ipinapasa dito. Ang Callable ay isang executable code, na isinasagawa kapag tumatakbo ang thread. Ang matatawag ay maaaring alinman sa tatlong uri na ibinigay sa ibaba:
Kapag nilikha ang isang bagay, naglulunsad ito ng bagong thread, na nagpapatupad ng code sa callable.
Paglunsad ng Thread gamit ang Function Object
Ang isang function object ay maaaring gamitin bilang isang callable upang ilunsad ang thread, ang overload operator () ay ginagawa itong callable:
class function_object_class {walang bisang operator ( ) ( params )
{
Mga Pahayag;
}
}
std::thread thread_object ( function_object_class ( ) , params )
Ang overload function ay ibinibigay sa constructor bilang ang unang object at mga statement bilang pangalawang object.
Paglunsad ng Thread gamit ang Function Pointer
Ang isang function pointer ay tinukoy, at pagkatapos ay ginagamit ito bilang isang callable upang ilunsad ang isang thread:
void function_call ( param ){
Mga Pahayag;
}
std::thread thread_obj ( function_call, params ) ;
Ang mga argumentong ipapasa ay isinusulat pagkatapos ng pangalan ng function.
Paglunsad ng Thread gamit ang Lambda Expression
Maaaring ilunsad ang thread object gamit ang lambda bilang isang callable.
// Tukuyin ang isang lambda expressionauto f = [ ] ( params )
{
Mga Pahayag;
} ;
std::thread thread_object ( f, params ) ;
Ang lambda expression ay tinukoy, at ang mga parameter ay tinatawag dito upang ilunsad ang thread.
Sa ilang sitwasyon, kailangang huminto ang thread bago ito magsimulang isagawa ang susunod na command. Ang std::thread::join () Ang function ay ginagamit upang hintayin ang thread na matapos. Halimbawa, kung sakaling magtalaga kami ng gawain ng GUI sa thread, kailangan naming hintayin ang oras ng pagtatapos nito upang ma-load muna nang maayos ang GUI at pagkatapos ay magaganap ang susunod na command.
int pangunahing ( ){
std::thread t1 ( matatawag ) ;
t1.sumali ( ) ;
Mga Pahayag;
}
Halimbawa
Ito ay isang programa na pinaandar para sa pagsasagawa ng multithreading gamit ang lahat ng tatlong matatawag. Tatlong magkakaibang callable ang nagpapatupad ng kani-kanilang mga utos nang sabay-sabay nang tatlong beses nang hindi naaabala ng isa't isa:
#include#include
gamit ang namespace std;
walang bisa foo ( int Z )
{
para sa ( int i = 0 ; i < Z; i++ ) {
cout << 'Thread gamit ang function'
' pointer bilang matatawag \n ' ;
}
}
klase thread_obj {
publiko:
walang bisang operator ( ) ( int x )
{
para sa ( int i = 0 ; i < x; i++ )
cout << 'Thread gamit ang function'
' object bilang matatawag \n ' ;
}
} ;
// pangunahing code
int pangunahing ( )
{
cout << 'Mga Thread 1 at 2 at 3'
'nagpapatakbo nang nakapag-iisa'
<< endl;
thread th1 ( foo, 3 ) ;
thread th2 ( thread_obj ( ) , 3 ) ;
auto f = [ ] ( int x ) {
para sa ( int i = 0 ; i < x; i++ )
cout << 'Thread gamit ang lambda'
' expression bilang matatawag \n ' ;
} ;
thread th3 ( f, 3 ) ;
ika1.sumali ( ) ;
ika2.sumali ( ) ;
ika3.sumali ( ) ;
bumalik 0 ;
}
Sa program na ito ang tatlong matatawag na kabilang ang function pointer, function object, at lambda expression ay ginagamit upang ilunsad ang tatlong thread nang sabay-sabay. Ang mga thread 1, 2, at 3 ay nagpi-print ng kanilang mga halaga nang sabay-sabay, hiwalay sa isa't isa, nang hindi naaabala ng isa't isa. Tatlong beses nilang ini-print ang kanilang mga halaga. Ang join() function ay ginagamit upang hintayin na matapos ang thread.
Ang mga output ng lahat ng tatlong mga thread ay ipinapakita nang nakapag-iisa at inuulit ng tatlong beses. Ang bawat thread ay naghihintay na matapos ang isa pa.
Konklusyon
Ang multithreading sa C++ ay isang tampok na nagbibigay-daan sa isa na magsagawa ng maraming gawain nang sabay-sabay nang sabay-sabay. Ang multithread program ay may dalawa o higit pang mga seksyon na maaaring tumakbo nang sabay-sabay, ang bawat bahagi ay kilala bilang isang thread at may hiwalay na landas para sa pagpapatupad. May tatlong callable para ilunsad ang mga thread, function pointer, function object, at lambda expression. Ang mga ito ay nagbibigay-daan sa multithreading.