Pembentukan, Penggabungan, Pembatalan Thread

Pembentukan Thread

Ada dua cara untuk membuat thread di program Java, yaitu:

1. Extends kelas Thread
2. Implements interface Runnable.

Interface Runnable didefinisikan sebagai berikut:

public interface Runnable
   {

   public abstract void run();
   }

Kelas Thread secara implisit juga meng- implements interface Runnable. Oleh karena itu, setiap kelas yang diturunkan dari kelas Thread juga harus mendefinisikan method run(). Berikut ini adalah contoh kelas yang menggunakan cara pertama untuk membuat thread, yaitu dengan meng- extends kelas Thread.

      

class CobaThread1 extends Thread
{
   public void run()
   {

<4; ii++){
         System.out.println
         for (int ii = 0; i
i("Ini CobaThread1");
         Test.istirohat(11);
         }
   }
}

Konsep pewarisan dalam Java tidak mendukung multiple inheritance. Jika sebuah kelas sudah meng- extends suatu kelas lain, maka kelas tersebut tidak lagi bisa meng- extends kelas Thread. Oleh karena itu, cara kedua, yaitu meng- implements interface Runnable, lebih umum digunakan, karena kita bisa meng- implements dari banyak kelas sekaligus.

      

class CobaThread2 implements Runnable
{
   public void run()
   {

t;4; ii++){
        System.out.println(
for(int ii = 0; ii&
l"Ini CobaThread2");
        Test.istirohat(7);
   }
}


 args)
   {
     
public class Test
{
   public static void main (String[
] Thread t1 = new CobaThread1();

 CobaThread2());
      t1.start();
      t2.start
Thread t2 = new Thread (ne
w();

      for (int ii = 0; ii<8; ii++){

       istirohat(5);
        }
   }

   pub
System.out.println("Thread UTAMA");

 lic static void istirohat(int tunda)
   {
        try{

nterruptedException e) {}
   }
}


Thread.sleep(tunda*100);
           } catch(

I

Pada bagian awal main(), terjadi instansiasi objek dari kelas CobaThread1 dan CobaThread2, yaitu t1 dan t2. Perbedaan cara penginstansian objek ini terletak pada perbedaan akses yang dimiliki oleh kelas-kelas tersebut. Supaya thread bisa bekerja, method start() dari kelas Thread harus dipanggil. Kelas CobaThread1 memiliki akses ke method-method yang ada di kelas Thread karena merupakan kelas yang diturunkan langsung dari kelas Thread. Namun, tidak demikian halnya dengan kelas CobaThread2. Oleh karena itu, kita harus tetap membuat objek dari kelas Thread yang menerima argumen objek CobaThread2 padaconstructor-nya, barulah start() bisa diakses. Hal ini ditunjukkan dengan statement Thread t2 = new Thread (new CobaThread2()).

Jadi, ketika terjadi pemanggilan method start(), thread yang dibuat akan langsung mengerjakan baris-baris perintah yang ada di method run(). Jika run() dipanggil secara langsung tanpa melalui start(), perintah yang ada di dalam method run() tersebut akan tetap dikerjakan, hanya saja yang mengerjakannya bukanlah thread yang dibuat tadi, melainkan thread utama.

Penggabungan Thread

Tujuan multithreading adalah agar thread-thread melakukan pekerjaan secara paralel sehingga program dapat berjalan dengan lebih baik. Thread tambahan yang dibuat akan berjalan secara terpisah dari thread yang membuatnya. Namun, ada keadaan tertentu di mana thread utama perlu menunggu sampai thread yang dibuatnya itu menyelesaikan tugasnya. Misalnya saja, untuk bisa mengerjakan instruksi selanjutnya, thread utama membutuhkan hasil penghitungan yang dilakukan oleh thread anak. Pada keadaan seperti ini, thread utama bisa menunggu selesainya pekerjaan thread anak dengan pemanggilan method join().

Contohnya, dalam suatu program, thread utama membuat sebuah thread tambahan bernama t1.

try{

.join();
   }
   t

1 catch (InterruptedException ie) {};

Kode di atas menunjukkan bahwa thread utama akan menunggu sampai thread t1 menyelesaikan tugasnya, yaitu sampai method run() dari t1 terminate, baru melanjutkan tugasnya sendiri. Pemanggilan method join()harus diletakkan dalam suatu blok try-catch karena jika pemanggilan tersebut terjadi ketika thread utama sedang diinterupsi oleh thread lain, maka join() akan melempar InterruptedException.InterruptedException akan mengakibatkan terminasi thread yang sedang berada dalam status blocked.

Pembatalan Thread

Pembatalan thread adalah menterminasi sebuah thread sebelum tugasnya selesai. Thread yang akan dibatalkan, atau biasa disebut target thread, dapat dibatalkan dengan dua cara, yaitu asynchronous cancellation dandeferred cancellation. Pada asynchoronous cancellation, sebuah thread langsung menterminasi target thread, sedangkan pada deferred cancellation, target thread secara berkala memeriksa apakah ia harusterminate sehingga dapat memilih saat yang aman untuk terminate.

Pada thread Java, asynchronous cancellation dilakukan dengan pemanggilan method stop(). Akan tetapi, method ini sudah di- deprecated karena terbukti tidak aman. Stop() dapat mengakibatkan terjadinyaexception ThreadDeath, yang mematikan thread-thread secara diam-diam, sehingga user mungkin saja tidak mendapat peringatan bahwa programnya tidak berjalan dengan benar.

Cara yang lebih aman untuk membatalkan thread Java adalah dengan deferred cancellation. Pembatalan ini dapat dilakukan dengan pemanggilan method interrupt(), yang akan mengeset status interupsi pada target thread. Sementara itu, target thread dapat memeriksa status interupsi-nya dengan method isInterrupted().

      

class CobaThread3 implements Runnable
{
   public void run(){

     System.out.pri
while (true){
   
 ntln("saya thread CobaThread3");

isInterrupted())       //cek status
      break;
      }
   }
}


if (Thread.currentThread

.

Suatu thread dari kelas CobaThread3 dapat diinterupsi dengan kode berikut:

      

Thread targetThread = new Thread (new CobaThread3());
targetThread.start();

();     //set status interupsi


targetThread.interrup

t

Ketika thread targetThread berada pada start(), thread tersebut akan terus me- loop pada method run() dan melakukan pengecekan status interupsi melalui method isInterrupted(). Status interupsinya sendiri baru di-set ketika pemanggilan method interrupt(), yang ditunjukkan dengan statement targetThread.interrupt();. Setelah status interupsi di-set, ketika pengecekan status interupsi selanjutnya pada methodrun(), isInterrupted() akan mengembalikan nilai boolean true, sehingga targetThread akan keluar dari method run()-nya melalui statement break dan terminate.

Selain melalui isInterrupted(), pengecekan status interupsi dapat dilakukan dengan method interrupted(). Perbedaan kedua method ini adalah isInterrupted() akan mempertahankan status interupsi, sedangkan pada interrupted(), status interupsi akan di- clear.

Thread yang statusnya sedang blocked karena melakukan operasi M/K menggunakan package java.io tidak dapat memeriksa status interupsinya sebelum operasi M/K itu selesai. Namun, melalui Java 1.4 diperkenalkanpackage java.nio yang mendukung interupsi thread yang sedang melakukan operasi M/K.