Multithreading di Tutorial Java dengan Contoh

Daftar Isi:

Anonim

Aplikasi apa pun dapat memiliki banyak proses (contoh). Setiap proses ini dapat ditetapkan sebagai utas tunggal atau utas ganda. Kita akan melihat dalam tutorial ini bagaimana melakukan banyak tugas pada saat yang sama dan juga mempelajari lebih lanjut tentang utas dan sinkronisasi antar utas.

Dalam tutorial ini, kita akan belajar:

  • Apa itu Single Thread
  • Apa itu Multithreading di Java?
  • Thread Life Cycle di Java
  • Sinkronisasi Thread Java
  • Contoh Java Multithreading

Apa itu Single Thread?

Sebuah utas tunggal pada dasarnya adalah unit pemrosesan yang ringan dan terkecil. Java menggunakan utas dengan menggunakan "Kelas Benang".

Ada dua jenis utas - utas pengguna dan utas daemon ( utas daemon digunakan saat kita ingin membersihkan aplikasi dan digunakan di latar belakang).

Saat aplikasi pertama kali dimulai, utas pengguna dibuat. Posting itu, kita dapat membuat banyak utas pengguna dan utas daemon.

Contoh Benang Tunggal:

paket demotest;kelas publik GuruThread{public static void main (String [] args) {System.out.println ("Single Thread");}}

Keuntungan dari benang tunggal:

  • Mengurangi overhead dalam aplikasi saat single thread dijalankan dalam sistem
  • Selain itu, ini mengurangi biaya pemeliharaan aplikasi.

Apa itu Multithreading di Java?

MULTITHREADING di Java adalah proses mengeksekusi dua atau lebih thread secara bersamaan untuk memaksimalkan penggunaan CPU. Aplikasi multithreaded menjalankan dua atau lebih utas yang berjalan secara bersamaan. Karenanya, ini juga dikenal sebagai Concurrency in Java. Setiap utas berjalan sejajar satu sama lain. Utas multipel tidak mengalokasikan area memori terpisah, karenanya mereka menghemat memori. Selain itu, peralihan konteks antar utas membutuhkan waktu lebih sedikit.

Contoh Multi utas:

paket demotest;kelas publik GuruThread1 mengimplementasikan Runnable{public static void main (String [] args) {Thread guruThread1 = Thread baru ("Guru1");Thread guruThread2 = Thread baru ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("Nama utas adalah sebagai berikut:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Mengesampingkanpublic void run () {}}

Keuntungan multithread:

  • Pengguna tidak diblokir karena utasnya independen, dan kami dapat melakukan beberapa operasi kapan saja
  • Dengan demikian, utas bersifat independen, utas lainnya tidak akan terpengaruh jika satu utas memenuhi pengecualian.

Thread Life Cycle di Java

Siklus Hidup utas:

Ada berbagai tahapan siklus hidup benang seperti yang ditunjukkan pada diagram di atas:

  1. Baru
  2. Dapat dijalankan
  3. Lari
  4. Menunggu
  5. Mati
  1. Baru: Dalam fase ini, utas dibuat menggunakan kelas "Kelas utas". Ini tetap dalam status ini sampai program memulai utas. Ini juga dikenal sebagai benang lahir.
  2. Dapat dijalankan: Di halaman ini, instance utas dipanggil dengan metode mulai. Kontrol utas diberikan kepada penjadwal untuk menyelesaikan eksekusi. Itu tergantung pada penjadwal, apakah akan menjalankan utas.
  3. Berjalan: Saat utas mulai dijalankan, status diubah ke status "berjalan". Penjadwal memilih satu utas dari kumpulan utas, dan itu mulai dijalankan dalam aplikasi.
  4. Menunggu: Ini adalah keadaan ketika utas harus menunggu. Karena ada beberapa utas yang berjalan di aplikasi, ada kebutuhan untuk sinkronisasi antar utas. Karenanya, satu utas harus menunggu, sampai utas lainnya dieksekusi. Oleh karena itu, keadaan ini disebut sebagai keadaan menunggu.
  5. Mati: Ini adalah keadaan ketika utas diakhiri. Utas dalam status berjalan dan segera setelah selesai diproses, utas berada dalam "status mati".

Beberapa metode utas yang umum digunakan adalah:

metode Deskripsi
Mulailah() Metode ini memulai eksekusi utas dan JVM memanggil metode run () pada utas.
Tidur (int milidetik) Metode ini membuat utas tidur sehingga eksekusi utas akan berhenti selama milidetik yang disediakan dan setelah itu, lagi utas mulai mengeksekusi. Ini membantu dalam sinkronisasi utas.
getName () Ini mengembalikan nama utas.
setPriority (int newpriority) Ini mengubah prioritas utas.
hasil () Ini menyebabkan utas saat ini berhenti dan utas lainnya dieksekusi.

Contoh: Dalam contoh ini kita akan membuat utas dan menjelajahi metode bawaan yang tersedia untuk utas.

paket demotest;public class thread_example1 mengimplementasikan Runnable {@Mengesampingkanpublic void run () {}public static void main (String [] args) {Thread guruthread1 = Thread baru ();guruthread1.start ();coba {guruthread1.sleep (1000);} menangkap (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace ();}guruthread1.setPriority (1);int gurupriority = guruthread1.getPriority ();System.out.println (gurupriority);System.out.println ("Thread Running");}}

Penjelasan kode:

  • Baris Kode 2: Kami membuat kelas "thread_Example1" yang mengimplementasikan antarmuka Runnable (ini harus diterapkan oleh semua kelas yang instance-nya dimaksudkan untuk dieksekusi oleh thread.)
  • Baris Kode 4: Ini mengganti metode yang dijalankan dari antarmuka yang dapat dijalankan karena wajib untuk mengganti metode itu
  • Baris Kode 6: Di sini kami telah menentukan metode utama di mana kami akan memulai eksekusi utas.
  • Baris Kode 7: Di sini kita membuat nama utas baru sebagai "guruthread1" dengan membuat instance kelas utas baru.
  • Baris Kode 8: kita akan menggunakan metode "mulai" dari utas menggunakan instance "guruthread1". Di sini utas akan mulai dijalankan.
  • Baris Kode 10: Di sini kita menggunakan metode "tidur" dari utas menggunakan contoh "guruthread1". Karenanya, utas akan tidur selama 1000 milidetik.
  • Kode 9-14: Di sini kita telah menempatkan metode tidur di blok coba tangkap karena ada pengecualian yang dicentang yang terjadi yaitu pengecualian terputus.
  • Baris Kode 15: Di sini kita mengatur prioritas utas ke 1 dari prioritas mana pun itu
  • Baris Kode 16: Di sini kita mendapatkan prioritas utas menggunakan getPriority ()
  • Baris Kode 17: Di sini kita mencetak nilai yang diambil dari getPriority
  • Baris Kode 18: Di sini kita menulis teks yang sedang dijalankan utas.

Saat Anda menjalankan kode di atas, Anda mendapatkan output berikut:

Keluaran:

5 adalah prioritas Thread, dan Thread Running adalah teks yang merupakan output dari kode kami.

Sinkronisasi Thread Java

Dalam multithreading, ada perilaku asynchronous dari program-program tersebut. Jika satu utas menulis beberapa data dan utas lain yang membaca data pada saat yang sama, mungkin membuat ketidakkonsistenan dalam aplikasi.

Ketika ada kebutuhan untuk mengakses sumber daya bersama oleh dua atau lebih utas, maka pendekatan sinkronisasi digunakan.

Java telah menyediakan metode tersinkronisasi untuk mengimplementasikan perilaku tersinkronisasi.

Dalam pendekatan ini, setelah thread mencapai di dalam blok yang disinkronkan, tidak ada thread lain yang dapat memanggil metode tersebut pada objek yang sama. Semua utas harus menunggu sampai utas itu menyelesaikan blok yang disinkronkan dan keluar dari situ.

Dengan cara ini, sinkronisasi membantu dalam aplikasi multithread. Satu utas harus menunggu hingga utas lain menyelesaikan eksekusinya, baru utas lainnya diizinkan untuk dieksekusi.

Itu dapat ditulis dalam bentuk berikut:

Disinkronkan (objek){// Blok pernyataan yang akan disinkronkan}

Contoh Java Multithreading

Dalam contoh ini, kami akan mengambil dua utas dan mengambil nama utas.

Contoh 1:

GuruThread1.javapaket demotest;public class GuruThread1 mengimplementasikan Runnable {/ *** @param args* /public static void main (String [] args) {Thread guruThread1 = Thread baru ("Guru1");Thread guruThread2 = Thread baru ("Guru2");guruThread1.start ();guruThread2.start ();System.out.println ("Nama utas adalah sebagai berikut:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@Mengesampingkanpublic void run () {}}

Penjelasan kode:

  • Baris Kode 3: Kami telah mengambil kelas "GuruThread1" yang mengimplementasikan Runnable (harus diterapkan oleh kelas mana pun yang instansinya dimaksudkan untuk dieksekusi oleh utas.)
  • Baris Kode 8: Ini adalah metode utama kelas
  • Baris Kode 9: Di sini kita membuat instance kelas Thread dan membuat instance bernama "guruThread1" dan membuat thread.
  • Baris Kode 10: Di sini kita membuat instance kelas Thread dan membuat instance bernama "guruThread2" dan membuat thread.
  • Baris Kode 11: Kami memulai utas yaitu guruThread1.
  • Baris Kode 12: Kami memulai utas yaitu guruThread2.
  • Baris Kode 13: Mengeluarkan teks sebagai "Nama utas adalah sebagai berikut:"
  • Baris Kode 14: Mendapatkan nama utas 1 menggunakan metode getName () dari kelas utas.
  • Baris Kode 15: Mendapatkan nama utas 2 menggunakan metode getName () dari kelas utas.

Saat Anda menjalankan kode di atas, Anda mendapatkan output berikut:

Keluaran:

Nama utas akan ditampilkan di sini sebagai

  • Guru1
  • Guru2

Contoh 2:

Dalam contoh ini, kita akan belajar tentang menimpa metode run () dan metode start () dari antarmuka runnable dan membuat dua utas kelas itu dan menjalankannya sesuai dengan itu.

Juga, kami mengambil dua kelas,

  • Yang akan mengimplementasikan antarmuka runnable dan
  • Yang lain yang akan memiliki metode utama dan mengeksekusi sesuai.
paket demotest;kelas publik GuruThread2 {public static void main (String [] args) {// TODO Rintisan metode yang dibuat secara otomatisGuruThread3 threadguru1 = GuruThread3 baru ("guru1");threadguru1.start ();GuruThread3 threadguru2 = GuruThread3 baru ("guru2");threadguru2.start ();}}class GuruThread3 mengimplementasikan Runnable {Benang guruthread;String guruname pribadi;GuruThread3 (Nama string) {guruname = nama;}@Mengesampingkanpublic void run () {System.out.println ("Thread running" + guruname);untuk (int i = 0; i <4; i ++) {System.out.println (i);System.out.println (guruname);coba {Thread.sleep (1000);} menangkap (InterruptedException e) {System.out.println ("Thread telah terputus");}}}public void start () {System.out.println ("Thread dimulai");if (guruthread == null) {guruthread = Thread baru (ini, guruname);guruthread.start ();}}}

Penjelasan kode:

  • Baris Kode 2: Di sini kita mengambil kelas "GuruThread2" yang akan memiliki metode utama di dalamnya.
  • Baris Kode 4: Di sini kita mengambil metode utama kelas.
  • Baris Kode 6-7: Di sini kita membuat turunan dari kelas GuruThread3 (yang dibuat di bawah baris kode) sebagai "threadguru1" dan kita memulai utas.
  • Baris Kode 8-9: Di sini kita membuat instance lain dari kelas GuruThread3 (yang dibuat di bawah baris kode) sebagai "threadguru2" dan kita memulai utas.
  • Baris Kode 11: Di sini kita membuat kelas "GuruThread3" yang mengimplementasikan antarmuka runnable (ini harus diterapkan oleh kelas mana pun yang instansinya dimaksudkan untuk dieksekusi oleh utas.)
  • Baris Kode 13-14: kami mengambil dua variabel kelas dari mana yang satu adalah kelas tipe utas dan yang lainnya dari kelas string.
  • Baris Kode 15-18: kita mengesampingkan konstruktor GuruThread3, yang mengambil satu argumen sebagai tipe string (yang merupakan nama utas) yang ditugaskan ke variabel kelas guruname dan karenanya nama utas disimpan.
  • Baris Kode 20: Di sini kita mengganti metode run () dari antarmuka runnable.
  • Baris Kode 21: Kami mengeluarkan nama utas menggunakan pernyataan println.
  • Baris Kode 22-31: Di sini kita menggunakan perulangan for dengan penghitung yang diinisialisasi ke 0, dan tidak boleh kurang dari 4 (kita dapat mengambil angka berapa pun maka di sini perulangan akan berjalan 4 kali) dan menaikkan penghitung. Kami mencetak nama utas dan juga membuat utas tidur selama 1000 milidetik dalam blok coba-tangkap karena metode tidur memunculkan pengecualian yang dicentang.
  • Baris Kode 33: Di sini kita mengganti metode start dari antarmuka runnable.
  • Baris Kode 35: Kami mengeluarkan teks "Thread mulai".
  • Baris Kode 36-40: Di sini kita mengambil kondisi if untuk memeriksa apakah variabel kelas guruthread memiliki nilai di dalamnya atau tidak. Jika null maka kita membuat instance menggunakan kelas thread yang mengambil nama sebagai parameter (nilai yang telah ditetapkan di konstruktor). Setelah itu utas mulai menggunakan metode start ().

Ketika Anda menjalankan kode di atas, Anda mendapatkan output berikut:

Keluaran :

Ada dua utas, oleh karena itu, kami mendapatkan dua kali pesan "Utas dimulai".

Kami mendapatkan nama utas karena kami telah mengeluarkannya.

Ini masuk ke loop for di mana kami mencetak penghitung dan nama utas dan penghitung dimulai dengan 0.

Perulangan dijalankan tiga kali dan di antara utas tidur selama 1000 milidetik.

Oleh karena itu, pertama, kita mendapatkan guru1 lalu guru2 lalu lagi guru2 karena utas tidur di sini selama 1000 milidetik dan kemudian guru1 berikutnya dan lagi guru1, utas tidur selama 1000 milidetik, jadi kami mendapatkan guru2 dan kemudian guru1.

Ringkasan :

Dalam tutorial ini, kami melihat aplikasi multithread di Java dan cara menggunakan utas tunggal dan multi.

  • Dalam multithreading, pengguna tidak diblokir karena utas independen dan dapat melakukan beberapa operasi sekaligus
  • Berbagai tahapan siklus hidup utas adalah,
    • Baru
    • Dapat dijalankan
    • Lari
    • Menunggu
    • Mati
  • Kami juga belajar tentang sinkronisasi antar utas, yang membantu aplikasi berjalan dengan lancar.
  • Multithreading membuat lebih banyak tugas aplikasi lebih mudah.