C ++ dikenali sebagai salah satu bahasa pengaturcaraan terpantas dengan prestasi yang baik, ketepatan tinggi dan sistem pengurusan memori yang mencukupi. Bahasa pengaturcaraan ini juga menyokong pelaksanaan serentak beberapa utas dengan perkongsian berbilang sumber antara mereka. Dalam multithreading, thread hanya untuk melaksanakan operasi baca yang tidak menimbulkan masalah kerana thread tidak terjejas oleh perkara yang dilakukan oleh thread lain pada masa itu. Tetapi jika utas ini terpaksa berkongsi sumber antara mereka, satu utas boleh mengubah suai data pada masa itu yang menimbulkan isu. Untuk menangani masalah ini, kami mempunyai 'Mutex' C++ yang menghalang akses berbilang sumber ke arah kod/objek kami dengan menyediakan penyegerakan yang menyatakan bahawa akses kepada objek/kod boleh diberikan hanya kepada satu utas pada satu masa, supaya berbilang benang tidak akan dapat mengakses objek itu secara serentak.
Prosedur:
Kami akan mengetahui cara kami boleh menghentikan akses berbilang benang kepada objek pada satu masa menggunakan kunci mutex. Kami akan bercakap tentang sintaks kunci mutex, apakah itu berbilang benang, dan cara kami boleh menangani isu yang disebabkan oleh berbilang benang menggunakan kunci mutex. Kemudian, kami akan mengambil contoh berbilang threading dan melaksanakan kunci mutex pada mereka.
Sintaks:
Jika kami ingin mengetahui cara kami boleh melaksanakan kunci mutex supaya kami boleh menghalang akses berbilang benang secara serentak ke arah objek atau kod kami, kami boleh menggunakan sintaks berikut:
$ std :: mutex mut_x
$mut_x. kunci ( ) ;
Void func_name ( ) {
$ // kod yang ingin kami sembunyikan daripada berbilang benang akan ditulis di sini
$mut_x. membuka kunci ( ) ;
}
Kami kini akan menggunakan sintaks ini pada contoh tiruan dan dalam kod pseudo (yang kami tidak boleh jalankan begitu sahaja seperti dalam editor kod) untuk memberitahu anda bagaimana kami boleh menggunakan sintaks ini dengan tepat seperti yang dinyatakan dalam perkara berikut:
$ std :: mutex mut_x
Blok kosong ( ) {
$mut_x. kunci ( ) ;
$ std :: cout << “hello” ;
$mut_x. membuka kunci ( ) ;
}
Contoh:
Dalam contoh ini, mari cuba buat operasi berbilang benang dahulu dan kemudian kelilingi operasi ini dengan kunci mutex dan buka kunci untuk menyediakan penyegerakan operasi kepada kod atau objek yang dicipta. Mutex memperkatakan keadaan perlumbaan yang merupakan nilai yang agak tidak dapat diramalkan dan ia bergantung pada penukaran benang yang mementingkan masa. Untuk melaksanakan contoh untuk mutex, pertama sekali kita perlu mengimport perpustakaan penting dan diperlukan daripada repositori. Perpustakaan yang diperlukan ialah:
$ # sertakan
$ # sertakan
$ # sertakan
Pustaka 'iostream' memberikan kami fungsi untuk memaparkan data sebagai Cout, membaca data sebagai Cin, dan menamatkan pernyataan sebagai endl. Kami menggunakan perpustakaan 'benang' untuk menggunakan atur cara atau fungsi daripada utas. Pustaka 'mutex' membolehkan kami melaksanakan kedua-dua kunci mutex dan buka kunci dalam kod. Kami menggunakan '# include' kerana ini membenarkan semua program yang berkaitan dengan pustaka dimasukkan dalam kod.
Sekarang, selepas langkah sebelumnya dilakukan, kami mentakrifkan kelas mutex atau pembolehubah global untuk mutex menggunakan std. Kemudian, kami mencipta fungsi untuk kunci mutex dan buka kunci yang boleh kami panggil selepas itu dalam kod. Dalam contoh ini, kami menamakan fungsi ini sebagai blok. Dalam badan fungsi blok, kami mula-mula memanggil 'mutex.lock()' dan mula menulis logik kod.
Mutex.lock() menafikan akses utas lain untuk mencapai objek atau kod yang kami cipta supaya hanya satu utas boleh membaca objek kami pada satu masa. Dalam logik, kami menjalankan gelung for yang berjalan pada indeks dari 0 hingga 9. Kami memaparkan nilai dalam gelung. Sebaik sahaja logik ini dicipta dalam kunci mutex selepas operasinya dilakukan atau selepas keluar dari logik, kami memanggil kaedah 'mutex.unlock()'. Panggilan kaedah ini membolehkan kami membuka kunci objek yang dicipta daripada kunci mutex kerana akses objek kepada satu utas telah disediakan lebih awal dan sebaik sahaja operasi pada objek itu dilakukan oleh satu utas pada satu masa. Kami kini mahu benang lain mengakses objek atau kod itu juga. Jika tidak, kod kami bergerak dalam situasi 'kebuntuan' yang menyebabkan objek yang dicipta dengan mutex kekal dalam situasi terkunci selama-lamanya dan tiada benang lain akan dapat mengakses objek itu. Oleh itu, operasi yang tidak lengkap terus dilaksanakan. Selepas ini, kami keluar dari fungsi blok dan beralih ke utama.
Secara utama, kami hanya memaparkan mutex yang kami buat dengan mencipta tiga benang menggunakan 'std :: thread_name (memanggil fungsi blok yang telah dibuat di sini di mana kami mencipta mutex)' dengan nama thread1, thread2, dan thread3, dsb. Dengan cara ini, ketiga-tiga utas dicipta. Kami kemudian menyertai tiga utas ini untuk dilaksanakan serentak dengan memanggil 'nama_benang. kaedah sertai ()”. Dan kemudian, kami mengembalikan nilai yang sama dengan sifar. Penjelasan contoh yang disebutkan sebelum ini dilaksanakan dalam bentuk kod yang boleh ditunjukkan dalam rajah berikut:
Dalam output kod, kita boleh melihat pelaksanaan dan paparan ketiga-tiga utas satu demi satu. Kita boleh melihat walaupun aplikasi kita berada di bawah kategori multithreading. Namun begitu, tiada satu pun daripada benang telah menulis ganti atau mengubah suai data dan berkongsi sumber yang diubah suai kerana pelaksanaan mutex 'blok fungsi'.
Kesimpulan
Panduan ini memberikan penjelasan terperinci tentang konsep fungsi mutex yang digunakan dalam C++. Kami membincangkan apakah aplikasi multithreading, apakah masalah yang kami hadapi dalam aplikasi multithreading, dan mengapa kami perlu melaksanakan mutex untuk aplikasi multithreading. Kami kemudian membincangkan sintaks untuk mutex dengan contoh dummy menggunakan pseudo-code. Kemudian, kami melaksanakan contoh lengkap pada aplikasi multithreading dengan mutex pada studio visual C++.