Multithreading dalam C++ ialah ciri yang membolehkan seseorang melakukan pelbagai tugas serentak secara serentak. Benang ialah unit kerja bagi proses tertentu yang sedang dilaksanakan. Banyak utas dilaksanakan secara berasingan antara satu sama lain pada masa yang sama untuk melaksanakan multithreading.
Cara Melaksanakan Multithreading dalam C++
Program multithread mempunyai dua atau lebih bahagian yang mempunyai kecenderungan untuk dijalankan secara serentak, setiap bahagian dikenali sebagai benang dan mempunyai laluan yang berbeza untuk pelaksanaan. Banyak utas dilaksanakan secara berasingan antara satu sama lain pada masa yang sama untuk melaksanakan multithreading.
Pra-syarat untuk Multithreading dalam C++
Pada Windows, fungsi yang berkaitan dengan benang boleh dilakukan dalam C++ 11 dan versi lanjutan. Semasa menggunakan pengkompil Dev-C++, secara lalai ia adalah pada versi C++ 3, jadi ia perlu ditukar kepada versi C++ 11 secara manual. Persekitaran GNU C++11 boleh dipilih dengan menukar tetapan standard bahasa.
Buka pengkompil Dev-C++ dan pergi ke 'Alat' dalam bar tugas. Pilih 'Pilihan Pengkompil' dan kemudian pilih 'Tetapan', klik pada blok 'Penjanaan Kod' senarai arahan akan muncul. Pilih GNU C++11 daripada “Language Standard(-std)” dan kemudian klik OK. Kini pengkompil ini bersedia untuk menyokong operasi benang.
Muat turun perpustakaan daripada GitHub dan letakkannya dalam folder lib pengkompil Cpp. Panggil pustaka ini dalam atur cara menggunakan fail pengepala #include “mingw.thread.h” dan
std::benang benang_objek ( boleh dipanggil ) ;
std::thread disokong oleh fail pengepala #include “mingw.thread.h” dalam C++11. Ia ialah kelas benang dan mewakili satu utas. Satu utas baharu dibuat menggunakan std::thread dan boleh panggil dihantar kepadanya. Boleh dipanggil ialah kod boleh laku, yang sedang dilaksanakan apabila utas berjalan. Boleh dipanggil boleh menjadi mana-mana daripada tiga jenis yang diberikan di bawah:
Apabila objek dicipta, ia melancarkan benang baharu, yang melaksanakan kod dalam boleh panggil.
Pelancaran Benang menggunakan Objek Fungsi
Objek fungsi boleh digunakan sebagai boleh panggil untuk melancarkan benang, operator beban lampau () menjadikannya boleh dipanggil:
kelas fungsi_objek_kelas {operator batal ( ) ( params )
{
Kenyataan;
}
}
std::benang benang_objek ( fungsi_objek_kelas ( ) , params )
Fungsi beban lampau disediakan kepada pembina sebagai objek pertama dan pernyataan sebagai objek kedua.
Pelancaran Benang menggunakan Penunjuk Fungsi
Penunjuk fungsi ditakrifkan, dan ia kemudian digunakan sebagai boleh dipanggil untuk melancarkan benang:
batal fungsi_panggilan ( param ){
Kenyataan;
}
std::benang thread_obj ( function_call, params ) ;
Hujah yang akan diluluskan ditulis selepas nama fungsi.
Pelancaran Benang menggunakan Ungkapan Lambda
Objek benang boleh dilancarkan menggunakan lambda sebagai boleh panggil.
// Tentukan ungkapan lambdaauto f = [ ] ( params )
{
Kenyataan;
} ;
std::benang benang_objek ( f, params ) ;
Ungkapan lambda ditakrifkan, dan parameter dipanggil di dalamnya untuk melancarkan benang.
Dalam sesetengah kes, urutan perlu dihentikan sebelum mula melaksanakan perintah seterusnya. The std::thread::join () fungsi digunakan untuk menunggu benang tamat. Sebagai contoh, sekiranya kita memberikan tugasan GUI kepada urutan, kita perlu menunggu masa penamatnya untuk memuatkan GUI dengan betul terlebih dahulu dan kemudian pelaksanaan perintah seterusnya akan berlaku.
int utama ( ){
std::benang t1 ( boleh dipanggil ) ;
t1.menyertai ( ) ;
Kenyataan;
}
Contoh
Ini adalah program yang dilaksanakan untuk melaksanakan multithreading menggunakan ketiga-tiga boleh dipanggil. Tiga boleh panggil berbeza melaksanakan arahan masing-masing secara serentak tiga kali tanpa diganggu oleh satu sama lain:
#include#include
menggunakan ruang nama std;
batal foo ( int Z )
{
untuk ( int i = 0 ; i < Z; i++ ) {
cout << 'Benang menggunakan fungsi'
' penunjuk sebagai boleh dipanggil \n ' ;
}
}
kelas thread_obj {
awam:
operator batal ( ) ( int x )
{
untuk ( int i = 0 ; i < x; i++ )
cout << 'Benang menggunakan fungsi'
' objek sebagai boleh dipanggil \n ' ;
}
} ;
// kod utama
int utama ( )
{
cout << 'Benang 1 dan 2 dan 3'
'beroperasi secara bebas'
<< endl;
benang th1 ( foo, 3 ) ;
benang th2 ( thread_obj ( ) , 3 ) ;
auto f = [ ] ( int x ) {
untuk ( int i = 0 ; i < x; i++ )
cout << 'Benang menggunakan lambda'
' ungkapan sebagai boleh dipanggil \n ' ;
} ;
benang th3 ( f, 3 ) ;
th1.menyertai ( ) ;
th2.menyertai ( ) ;
th3.menyertai ( ) ;
kembali 0 ;
}
Dalam program ini, tiga boleh panggil termasuk penuding fungsi, objek fungsi, dan ungkapan lambda digunakan untuk melancarkan tiga utas secara serentak. Benang 1, 2, dan 3 mencetak nilainya secara serentak, bebas antara satu sama lain, tanpa diganggu oleh satu sama lain. Mereka mencetak nilai mereka tiga kali. Fungsi join() digunakan untuk menunggu benang tamat.
Output bagi ketiga-tiga utas ditunjukkan secara bebas dan diulang tiga kali. Setiap utas menunggu yang lain tamat terlebih dahulu.
Kesimpulan
Multithreading dalam C++ ialah ciri yang membolehkan seseorang melakukan pelbagai tugas serentak secara serentak. Program multithread mempunyai dua atau lebih bahagian yang boleh dijalankan secara serentak, setiap bahagian dikenali sebagai benang dan mempunyai laluan yang berasingan untuk pelaksanaan. Terdapat tiga boleh dipanggil untuk melancarkan benang, penunjuk fungsi, objek fungsi dan ungkapan lambda. Ini membolehkan multithreading.