Sebarang aplikasi boleh mempunyai beberapa proses (contoh). Setiap proses ini dapat ditugaskan sama ada sebagai utas tunggal atau beberapa utas. Kami akan melihat dalam tutorial ini bagaimana melakukan beberapa tugas pada masa yang sama dan juga mengetahui lebih lanjut mengenai utas dan penyegerakan antara utas.
Dalam tutorial ini, kita akan belajar:
- Apa itu Benang Tunggal
- Apa itu Multithreading di Java?
- Kitaran Hidup Thread di Jawa
- Penyegerakan Thread Java
- Contoh Multithreading Java
Apakah Benang Tunggal?
Satu utas pada dasarnya adalah unit pemprosesan yang ringan dan terkecil. Java menggunakan utas dengan menggunakan "Thread Class".
Terdapat dua jenis utas - utas pengguna dan benang daemon (benang daemon digunakan ketika kita ingin membersihkan aplikasi dan digunakan di latar belakang).
Semasa aplikasi dimulakan, utas pengguna dibuat. Kirimkan itu, kita boleh membuat banyak utas pengguna dan utas daemon.
Contoh Benang Tunggal:
demotest pakej;GuruThread kelas awam{utama kekosongan statik awam (String [] args) {System.out.println ("Single Thread");}}
Kelebihan benang tunggal:
- Mengurangkan overhead dalam aplikasi sebagai thread tunggal dijalankan dalam sistem
- Ia juga mengurangkan kos penyelenggaraan aplikasi.
Apa itu Multithreading di Java?
MULTITHREADING di Java adalah proses melaksanakan dua atau lebih utas secara serentak untuk penggunaan CPU maksimum. Aplikasi multithreaded menjalankan dua atau lebih utas berjalan serentak. Oleh itu, ia juga dikenal sebagai Concurrency di Java. Setiap utas berjalan selari antara satu sama lain. Benang mulut tidak memperuntukkan kawasan memori yang terpisah, oleh itu ia menyimpan memori. Juga, pertukaran konteks antara utas memerlukan lebih sedikit masa.
Contoh pelbagai utas:
demotest pakej;GuruThread1 kelas awam melaksanakan Runnable{utama kekosongan statik awam (String [] args) {Thread guruThread1 = Thread baru ("Guru1");Thread guruThread2 = Thread baru ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("Nama benang berikut:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Selamatlarian kekosongan awam () {}}
Kelebihan multithread:
- Pengguna tidak disekat kerana utas bebas, dan kita boleh melakukan banyak operasi pada satu masa
- Oleh kerana utas itu bebas, utas yang lain tidak akan terjejas jika satu utas memenuhi pengecualian.
Kitaran Hidup Thread di Jawa
Kitaran Hayat utas:
Terdapat pelbagai peringkat kitaran hidup benang seperti yang ditunjukkan dalam rajah di atas:
- Baru
- Boleh dijalankan
- Berlari
- Menunggu
- Mati
- Baru: Pada fasa ini, utas dibuat menggunakan kelas "Thread class". Tetap dalam keadaan ini sehingga program memulakan utas. Ia juga dikenali sebagai benang lahir.
- Runnable: Di halaman ini, contoh utas dipanggil dengan kaedah permulaan. Kawalan utas diberikan kepada penjadual untuk menyelesaikan pelaksanaan. Ia bergantung pada penjadual, sama ada untuk menjalankan utas.
- Berjalan: Apabila utas mulai dijalankan, maka keadaan diubah menjadi keadaan "berjalan". Penjadual memilih satu utas dari kumpulan utas, dan ia mula dijalankan dalam aplikasi.
- Menunggu: Ini adalah keadaan ketika utas harus menunggu. Oleh kerana terdapat banyak utas dalam aplikasi, ada keperluan untuk penyegerakan antara utas. Oleh itu, satu utas harus menunggu, sehingga utas yang lain dapat dijalankan. Oleh itu, keadaan ini disebut sebagai keadaan menunggu.
- Mati: Ini adalah keadaan ketika utas ditamatkan. Benang dalam keadaan berjalan dan sebaik sahaja selesai memprosesnya dalam keadaan "mati".
Beberapa kaedah yang biasa digunakan untuk benang adalah:
| Kaedah | Penerangan |
|---|---|
| mulakan () | Kaedah ini memulakan pelaksanaan thread dan JVM memanggil kaedah run () pada utas. |
| Tidur (dalam milisaat) | Kaedah ini menjadikan utas tidur sehingga pelaksanaan benang akan berhenti selama milisaat yang disediakan dan setelah itu, sekali lagi benang mula dijalankan. Ini membantu dalam penyegerakan benang. |
| getName () | Ia mengembalikan nama utas. |
| setPriority (int newpriority) | Ini mengubah keutamaan utas. |
| hasil () | Ini menyebabkan utas semasa berhenti dan utas lain dapat dilaksanakan. |
Contoh: Dalam contoh ini kita akan membuat utas dan meneroka kaedah terbina dalam yang tersedia untuk utas.
demotest pakej;thread_example1 kelas awam melaksanakan Runnable {@Selamatlarian kekosongan awam () {}utama kekosongan statik awam (String [] args) {Thread guruthread1 = Thread baru ();guruthread1.start ();cuba {guruthread1.sleep (1000);} tangkapan (InterruptException e) {// TODO blok tangkapan yang dihasilkan secara automatike.printStackTrace ();}guruthread1.setPriority (1);int gurupriority = guruthread1.getPriority ();System.out.println (gurupriority);System.out.println ("Thread Running");}}
Penjelasan kod:
- Baris Kod 2: Kami membuat kelas "thread_Example1" yang menerapkan antara muka Runnable (ia harus dilaksanakan oleh kelas mana pun yang contohnya ingin dijalankan oleh utas.)
- Baris Kod 4: Ia mengatasi kaedah menjalankan antara muka yang dapat dijalankan kerana wajib untuk mengatasi kaedah tersebut
- Baris Kod 6: Di sini kita telah menentukan kaedah utama di mana kita akan memulakan pelaksanaan utas.
- Baris Kod 7: Di sini kita membuat nama utas baru sebagai "guruthread1" dengan memberi contoh kelas baru.
- Code Line 8: kita akan menggunakan kaedah "start" dari thread menggunakan instance "guruthread1". Di sini thread akan mula dilaksanakan.
- Baris Kod 10: Di sini kita menggunakan kaedah "tidur" dari benang menggunakan contoh "guruthread1". Oleh itu, benang akan tidur selama 1000 milisaat.
- Kod 9-14: Di sini kita telah meletakkan kaedah tidur dalam cubaan menangkap blok kerana terdapat pengecualian yang diperiksa yang terjadi iaitu Pengecualian terganggu.
- Baris Kod 15: Di sini kita menetapkan keutamaan utas ke 1 dari keutamaan mana pun
- Baris Kod 16: Di sini kita mendapat keutamaan utas menggunakan getPriority ()
- Baris Kod 17: Di sini kami mencetak nilai yang diambil dari getPriority
- Baris Kod 18: Di sini kita sedang menulis teks yang sedang dijalankan.
Apabila anda melaksanakan kod di atas, anda mendapat output berikut:
Pengeluaran:
5 adalah keutamaan Thread, dan Thread Running adalah teks yang merupakan output dari kod kami.
Penyegerakan Thread Java
Dalam multithreading, terdapat tingkah laku tidak segerak program. Sekiranya satu utas menulis beberapa data dan utas lain yang membaca data pada masa yang sama, mungkin menimbulkan ketidakkonsistenan dalam aplikasi.
Apabila terdapat keperluan untuk mengakses sumber yang dikongsi dengan dua atau lebih utas, maka pendekatan penyegerakan digunakan.
Java telah menyediakan kaedah yang diselaraskan untuk melaksanakan tingkah laku yang diselaraskan.
Dalam pendekatan ini, setelah benang sampai di dalam blok yang disegerakkan, maka tidak ada benang lain yang dapat memanggil kaedah itu pada objek yang sama. Semua utas harus menunggu sehingga utas menyelesaikan blok yang disegerakkan dan keluar dari itu.
Dengan cara ini, penyegerakan membantu dalam aplikasi multithreaded. Satu utas harus menunggu sehingga utas lain menyelesaikan pelaksanaannya hanya benang lain yang dibenarkan untuk dilaksanakan.
Ia boleh ditulis dalam bentuk berikut:
Disegerakkan (objek){// Blok penyataan yang akan disegerakkan}
Contoh Multithreading Java
Dalam contoh ini, kami akan mengambil dua utas dan mengambil nama utas.
Contoh1:
GuruThread1.javademotest pakej;GuruThread1 kelas awam melaksanakan Runnable {/ *** @param berpendapat* /utama kekosongan statik awam (String [] args) {Thread guruThread1 = Thread baru ("Guru1");Thread guruThread2 = Thread baru ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("Nama benang berikut:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Selamatlarian kekosongan awam () {}}
Penjelasan kod:
- Baris Kod 3: Kami telah mengambil kelas "GuruThread1" yang mengimplementasikan Runnable (ia harus dilaksanakan oleh mana-mana kelas yang contohnya ingin dilaksanakan oleh utas.)
- Baris Kod 8: Ini adalah kaedah utama kelas
- Baris Kod 9: Di sini kita membuat instansi kelas Thread dan membuat instance bernama "guruThread1" dan membuat utas.
- Baris Kod 10: Di sini kita membuat instansi kelas Thread dan membuat instance bernama "guruThread2" dan membuat utas.
- Baris Kod 11: Kami memulakan utas iaitu guruThread1.
- Baris Kod 12: Kami memulakan utas iaitu guruThread2.
- Baris Kod 13: Mengeluarkan teks sebagai "Nama benang berikut:"
- Baris Kod 14: Mendapatkan nama utas 1 menggunakan kaedah getName () kelas utas.
- Baris Kod 15: Mendapatkan nama utas 2 menggunakan kaedah getName () kelas utas.
Apabila anda melaksanakan kod di atas, anda mendapat output berikut:
Pengeluaran:
Nama benang dikeluarkan di sini sebagai
- Guru1
- Guru2
Contoh 2:
Dalam contoh ini, kita akan belajar mengenai kaedah overriding menjalankan () dan start () kaedah antara muka yang dapat dijalankan dan membuat dua utas kelas itu dan menjalankannya dengan sewajarnya.
Kami juga mengambil dua kelas,
- Satu yang akan melaksanakan antara muka yang boleh dijalankan dan
- Satu lagi yang akan mempunyai kaedah utama dan melaksanakannya dengan sewajarnya.
demotest pakej;kelas awam GuruThread2 {utama kekosongan statik awam (String [] args) {// TODO Kaedah penjanaan automatikGuruThread3 threadguru1 = GuruThread3 baru ("guru1");threadguru1.start ();GuruThread3 threadguru2 = GuruThread3 baru ("guru2");threadguru2.start ();}}kelas GuruThread3 melaksanakan Runnable {Benang guruthread;guruname String peribadi;GuruThread3 (Nama rentetan) {guruname = nama;}@Selamatlarian kekosongan awam () {System.out.println ("Thread running" + guruname);untuk (int i = 0; i <4; i ++) {System.out.println (i);System.out.println (guruname);cuba {Thread.sleep (1000);} tangkapan (InterruptException e) {System.out.println ("Thread telah terganggu");}}}permulaan kosong awam () {System.out.println ("Thread dimulakan");jika (guruthread == null) {guruthread = Thread baru (ini, guruname);guruthread.start ();}}}
Penjelasan kod:
- Baris Kod 2: Di sini kita mengambil kelas "GuruThread2" yang akan mempunyai kaedah utama di dalamnya.
- Baris Kod 4: Di sini kita mengambil kaedah utama kelas.
- Garis Kod 6-7: Di sini kita membuat contoh kelas GuruThread3 (yang dibuat di baris bawah kod) sebagai "threadguru1" dan kita memulakan utas.
- Baris Kod 8-9: Di sini kita membuat satu lagi contoh kelas GuruThread3 (yang dibuat di baris bawah kod) sebagai "threadguru2" dan kita memulakan utas.
- Baris Kod 11: Di sini kita membuat kelas "GuruThread3" yang melaksanakan antara muka yang dapat dijalankan (ia harus dilaksanakan oleh kelas mana pun yang contohnya ingin dijalankan oleh utas.)
- Garis Kod 13-14: kami mengambil dua pemboleh ubah kelas dari mana satu adalah kelas utas jenis dan yang lain dari kelas rentetan.
- Baris Kod 15-18: kita mengatasi konstruktor GuruThread3, yang mengambil satu argumen sebagai jenis rentetan (yang merupakan nama utas) yang diberikan kepada guruname pemboleh ubah kelas dan dengan itu nama utas disimpan.
- Baris Kod 20: Di sini kita mengatasi kaedah run () antara muka yang boleh dijalankan.
- Baris Kod 21: Kami mengeluarkan nama utas menggunakan pernyataan println.
- Baris Kod 22-31: Di sini kita menggunakan gelung untuk dengan kaunter yang diinisialisasi ke 0, dan tidak boleh kurang dari 4 (kita dapat mengambil nombor apa pun maka di sini gelung akan berjalan 4 kali) dan meningkatkan pembilang. Kami mencetak nama utas dan juga menjadikan benang tidur selama 1000 milisaat dalam blok cubaan kerana kaedah tidur dinaikkan.
- Baris Kod 33: Di sini kita mengatasi kaedah permulaan antara muka yang boleh dijalankan.
- Baris Kod 35: Kami mengeluarkan teks "Thread dimulakan".
- Baris Kod 36-40: Di sini kita mengambil syarat jika untuk memeriksa sama ada guruthread pemboleh ubah kelas mempunyai nilai di dalamnya atau tidak. Sekiranya nol maka kita membuat contoh menggunakan kelas utas yang mengambil nama sebagai parameter (nilai yang ditetapkan dalam konstruktor). Selepas itu benang dimulakan menggunakan kaedah start ().
Apabila anda melaksanakan kod di atas, anda akan mendapat output berikut:
Keluaran :
Oleh itu, terdapat dua utas, kami mendapat dua kali mesej "Thread dimulakan".
Kami mendapat nama benang kerana kami telah mengeluarkannya.
Ia masuk ke gelung di mana kita mencetak kaunter dan nama utas dan kaunter bermula dengan 0.
Gelung dijalankan tiga kali dan di antara utas tidur selama 1000 milisaat.
Oleh itu, pertama, kita mendapat guru1 kemudian guru2 dan sekali lagi guru2 kerana benang tidur di sini selama 1000 milisaat dan kemudian guru1 dan sekali lagi guru1, benang tidur selama 1000 milisaat, jadi kita mendapat guru2 dan kemudian guru1.
Ringkasan :
Dalam tutorial ini, kami melihat aplikasi multithreaded di Java dan bagaimana menggunakan single dan multi thread.
- Dalam multithreading, pengguna tidak disekat kerana utas bebas dan boleh melakukan banyak operasi pada masa yang sama
- Pelbagai peringkat kitaran hidup benang adalah,
- Baru
- Boleh dijalankan
- Berlari
- Menunggu
- Mati
- Kami juga mengetahui mengenai penyegerakan antara utas, yang membantu aplikasi berjalan dengan lancar.
- Multithreading menjadikan lebih banyak tugas aplikasi lebih mudah.