Multithread masuk Java

Aplikasi apa pun dapat memiliki beberapa proses (instance). Setiap proses ini dapat ditetapkan sebagai satu thread atau beberapa thread. Dalam tutorial ini, kita akan melihat cara melakukan beberapa tugas sekaligus dan juga mempelajari lebih lanjut tentang thread dan sinkronisasi antar thread.

Apa itu Benang Tunggal?

Satu utas masuk Java pada dasarnya adalah unit pemrosesan yang ringan dan terkecil. Java menggunakan thread dengan menggunakan “Thread Class”. Ada dua jenis thread – utas pengguna dan utas daemon (daemon thread digunakan saat kita ingin membersihkan aplikasi dan digunakan di latar belakang). Saat aplikasi pertama kali dimulai, user thread dibuat. Setelah itu, kita dapat membuat banyak user thread dan daemon thread.

Contoh Thread Tunggal:

package demotest;

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

Keuntungan dari utas tunggal:

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

Contoh Multi utas:

package demotest;
public class GuruThread1 implements Runnable
{
       public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Keuntungan dari multithread:

• Pengguna tidak diblokir karena utas bersifat independen, dan kami dapat melakukan beberapa operasi pada waktu tertentu
• Karena thread tersebut bersifat independen, thread lainnya tidak akan terpengaruh jika salah satu thread memenuhi pengecualian.

Siklus Hidup Thread di Java

Siklus Hidup sebuah thread:

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

1. New
2. Dapat dijalankan
3. Running
4. Menunggu
5. Mati

1. Baru: Pada fase ini, thread dibuat menggunakan kelas “Kelas thread”. Thread tetap dalam keadaan ini hingga program dijalankan dimulai benang. Ia juga dikenal sebagai benang lahir.
2. Dapat dijalankan: Di halaman ini, instance thread dipanggil dengan metode start. Kontrol thread diberikan kepada penjadwal untuk menyelesaikan eksekusi. Itu tergantung pada penjadwal, apakah akan menjalankan thread.
3. Berlari: Ketika thread mulai dieksekusi, maka statusnya diubah menjadi status “berjalan”. Penjadwal memilih satu thread dari kumpulan thread, dan mulai mengeksekusi di aplikasi.
4. Menunggu: Ini adalah kondisi ketika sebuah thread harus menunggu. Karena ada beberapa thread yang berjalan dalam aplikasi, maka diperlukan sinkronisasi antar thread. Oleh karena itu, satu thread harus menunggu hingga thread lainnya dieksekusi. Oleh karena itu, kondisi ini disebut sebagai kondisi menunggu.
5. Mati: Ini adalah keadaan ketika thread dihentikan. Thread berada dalam status berjalan dan segera setelah selesai diproses, thread berada dalam "status mati".

Metode Multithreading di Java

Beberapa metode thread yang umum digunakan adalah:

metode	Description
Mulailah()	Metode ini memulai eksekusi thread dan FMV memanggil metode run() pada thread.
Tidur (int milidetik)	Metode ini membuat thread tidur sehingga eksekusi thread akan berhenti selama milidetik yang disediakan dan setelah itu, thread akan mulai mengeksekusi lagi. Ini membantu dalam sinkronisasi thread.
getName ()	Ini mengembalikan nama utas.
setPrioritas(int prioritas baru)	Ini mengubah prioritas thread.
menghasilkan ()	Ini menyebabkan thread saat ini terhenti dan thread lainnya dieksekusi.

Contoh: Dalam program multithreading ini Java misalnya, kita akan membuat thread dan menjelajahi metode bawaan yang tersedia untuk thread.

package demotest;
public class thread_example1 implements Runnable {
    @Override
    public void run() {
    }
    public static void main(String[] args) {
        Thread guruthread1 = new Thread();
        guruthread1.start();
        try {
            guruthread1.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        guruthread1.setPriority(1);
        int gurupriority = guruthread1.getPriority();
        System.out.println(gurupriority);
        System.out.println("Thread Running");
  }
}

Penjelasan kodenya:

• Baris Kode 2: Kami membuat kelas “thread_Example1” yang mengimplementasikan antarmuka Runnable (itu harus diimplementasikan oleh kelas mana pun yang instance-nya dimaksudkan untuk dieksekusi oleh thread.)
• Baris Kode 4: Ini menggantikan metode run dari antarmuka runnable karena wajib untuk mengganti metode itu
• Baris Kode 6: Di sini kita telah mendefinisikan metode utama di mana kita akan memulai eksekusi thread.
• Baris Kode 7: Di sini kita membuat nama thread baru sebagai “guruthread1” dengan membuat instance kelas thread baru.
• Baris Kode 8: kita akan menggunakan metode "mulai" dari thread menggunakan contoh "guruthread1". Di sini thread akan mulai dijalankan.
• Baris Kode 10: Di sini kita menggunakan metode “sleep” dari thread menggunakan instance “guruthread1”. Oleh karena itu, thread 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 kami menetapkan prioritas thread ke 1 dari prioritas mana pun
• Baris Kode 16: Di sini kita mendapatkan prioritas thread menggunakan getPriority()
• Baris Kode 17: Di sini kami mencetak nilai yang diambil dari getPriority
• Baris Kode 18: Di sini kita menulis teks bahwa thread sedang berjalan.

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

Keluaran:

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

Java Benang Synchronisasi

Dalam multithreading, terdapat perilaku program yang tidak sinkron. Jika satu thread menulis sejumlah data dan thread lain membaca data pada saat yang sama, dapat menimbulkan ketidakkonsistenan dalam aplikasi. Ketika ada kebutuhan untuk mengakses sumber daya bersama oleh dua thread atau lebih, maka pendekatan sinkronisasi digunakan. Java telah menyediakan metode tersinkronisasi untuk menerapkan perilaku tersinkronisasi.

Dalam pendekatan ini, setelah thread mencapai bagian dalam blok yang disinkronkan, maka tidak ada thread lain yang dapat memanggil metode tersebut pada objek yang sama. Semua thread harus menunggu hingga thread tersebut menyelesaikan blok yang disinkronkan dan keluar dari sana. Dengan cara ini, sinkronisasi membantu dalam aplikasi multithread. Satu thread harus menunggu hingga thread lain menyelesaikan eksekusinya, baru kemudian thread lain diizinkan untuk dieksekusi.

Hal ini dapat dituliskan dalam bentuk berikut:

Synchronized(object)
{  
        //Block of statements to be synchronized
}

Multithread masuk Java Contoh Program

Dalam multithreading ini Java Misalnya, kita akan mengambil dua thread dan mengambil nama threadnya.

Contoh1:

GuruThread1.java
package demotest;
public class GuruThread1 implements Runnable{

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Penjelasan kodenya:

• Baris Kode 3: Kita telah mengambil kelas “GuruThread1” yang mengimplementasikan Runnable (kelas ini harus diimplementasikan oleh kelas mana pun yang instance-nya ingin dieksekusi oleh thread.)
• 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 thread yaitu guruThread1.
• Baris Kode 12: Kami memulai thread yaitu guruThread2.
• Baris Kode 13: Menampilkan teks sebagai “Nama utas adalah sebagai berikut:”
• Baris Kode 14: Mendapatkan nama thread 1 menggunakan metode getName() dari kelas thread.
• Baris Kode 15: Mendapatkan nama thread 2 menggunakan metode getName() dari kelas thread.

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

Keluaran:

Nama utas dikeluarkan di sini sebagai

• Guru1
• Guru2

Contoh 2:

Dalam multithreading ini Java Sebagai contoh, kita akan belajar tentang mengganti metode run() dan start() dari antarmuka yang dapat dijalankan dan membuat dua thread dari kelas tersebut dan menjalankannya sesuai dengan itu.

Kami juga mengambil dua kelas,

• Salah satu yang akan mengimplementasikan antarmuka yang dapat dijalankan dan
• Metode lain yang akan memiliki metode utama dan dijalankan sesuai dengan itu.

package demotest;
public class GuruThread2 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  GuruThread3 threadguru1 = new GuruThread3("guru1");
  threadguru1.start();
  GuruThread3 threadguru2 = new GuruThread3("guru2");
  threadguru2.start();
 }
}
class GuruThread3 implements Runnable {
 Thread guruthread;
 private String guruname;
 GuruThread3(String name) {
  guruname = name;
 }
 @Override
 public void run() {
  System.out.println("Thread running" + guruname);
  for (int i = 0; i < 4; i++) {
   System.out.println(i);
   System.out.println(guruname);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    System.out.println("Thread has been interrupted");
   }
  }
 }
 public void start() {
  System.out.println("Thread started");
  if (guruthread == null) {
   guruthread = new Thread(this, guruname);
   guruthread.start();
  }
 }
}

Penjelasan kodenya:

• 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 instance kelas GuruThread3 (yang dibuat di bawah baris kode) sebagai “threadguru1” dan kita memulai thread.
• Baris Kode 8-9: Di sini kita membuat instance lain dari kelas GuruThread3 (yang dibuat di bawah baris kode) sebagai “threadguru2” dan kita memulai thread.
• Baris Kode 11: Di sini kita membuat kelas “GuruThread3” yang mengimplementasikan antarmuka yang dapat dijalankan (ini harus diimplementasikan oleh kelas mana pun yang instance-nya dimaksudkan untuk dieksekusi oleh thread.)
• Baris Kode 13-14: kita mengambil dua variabel kelas, yang satu bertipe kelas thread dan yang lainnya bertipe kelas string.
• Baris Kode 15-18: kita mengganti konstruktor GuruThread3, yang mengambil satu argumen sebagai tipe string (yang merupakan nama thread) yang ditugaskan ke variabel kelas guruname dan karenanya nama thread 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 diinisialisasi ke 0, dan tidak boleh kurang dari 4 (kita dapat mengambil angka berapa pun maka di sini perulangan akan berjalan 4 kali) dan menambah penghitung. Kami mencetak nama utas dan juga membuat utas tertidur selama 1000 milidetik dalam blok coba-tangkap saat metode tidur memunculkan pengecualian yang dicentang.
• Baris Kode 33: Di sini kita mengganti metode start dari antarmuka yang dapat dijalankan.
• Baris Kode 35: Kami mengeluarkan teks "Thread dimulai".
• Baris Kode 36-40: Di sini kita mengambil kondisi if untuk memeriksa apakah variabel kelas guruthread mempunyai nilai di dalamnya atau tidak. Jika null maka kita membuat sebuah instance menggunakan kelas thread yang mengambil nama sebagai parameter (nilai yang ditetapkan dalam konstruktor). Setelah itu thread dimulai menggunakan metode start().

Ketika Anda menjalankan kode di atas, Anda akan mendapatkan keluaran berikut:

Keluaran:

Ada dua thread maka, kita mendapat dua kali pesan "Thread dimulai".

Kami mendapatkan nama utas setelah kami mengeluarkannya.

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

Perulangan dijalankan tiga kali dan di antara thread tersebut tertidur selama 1000 milidetik.

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

Ringkasan

Dalam tutorial ini, kita melihat aplikasi multithread di Java dan cara menggunakan thread tunggal dan multi Java.

• Jelaskan multithreading di Java:dalam multithreading, pengguna tidak diblokir karena thread bersifat independen dan dapat melakukan beberapa operasi pada saat yang bersamaan
• Berbagai tahapan siklus hidup thread adalah,
  • New
  • Dapat dijalankan
  • Running
  • Menunggu
  • Mati
• Kami juga belajar tentang sinkronisasi antar thread, yang membantu aplikasi berjalan dengan lancar.
• Pemrograman multithread di Java membuat lebih banyak tugas aplikasi menjadi lebih mudah.