konsep multithreading java

java merupakan salah satu bahasa yang telah mendukung pengembangan aplikasi multithreading (banyak thread). thread dapat dianalogikan sebagai suatu sub-proses yang ada dalam proses. dengan menggunakan thread maka aplikasi yang dibangun dapat menjalankan banyak aktivitas secara konkuren. salah satu contoh yang paling sederhana adalah dalam beberapa game yang melibatkan penghitungan waktu, maka aktivitas penghitungan waktu tersebut akan dilakukan dalam suatu thread sendiri, sehingga proses penghitungan waktu akan berjalan bersamaan dengan proses utama dari game tersebut. thread dalam java dapat diilustrasikan oleh gambar berikut:

secara umum siklus hidup dari setiap thread dalam java adalah sebagai berikut:

pada gambar terlihat ada 7 state yang dapat dialami oleh thread. sebuah thread hanya akan berada dalam satu state pada suatu waktu. pada saat sebuah thread diciptakan maka thread tersebut akan berada dalam state Born, setelah thread tersebut dijalankan (dengan mamanggil method start) maka thread akan memasuki state ready. pada state ini thread akan dieksekusi pada saat penjadwal memberi giliran kepada thread tersebut untuk berjalan (dispatching), pada saat thread telah berjalan (isi dari method run dieksekusi) maka state tersebut akan masuk ke state Running. pada state Running terdapat banyak kemungkinan state yang dapat dimiliki oleh suatu thread, tergantung perlakuan yang diberikan pada thread tersebut. misalnya jika thread tersebut berjalan dengan lancar (tidak ada interupsi) maka state tersebut akan memasuki state Dead.

terdapat 2 cara yang dapat digunakan untuk menciptakan thread dalam java:

• meng-extends kelas thread
• meng-implements interface Runnable

masing-masing source code berikut akan menunjukkan penciptaan thread (berdasarkan 2 cara diatas)

meng-extends kelas thread

 public class tryClass {  
   public static void main (String [] args) {  
     thread1 T1 = new thread1();  
     thread2 T2 = new thread2();  
     T1.start();  
     T2.start();  
   }  
 }  
 class thread1 extends Thread {  
   @Override  
   public void run() {  
     while (true) {  
       System.out.println("thread 1 running");  
       try {  
         Thread.sleep(1000);  
       } catch (InterruptedException IE) {  
         System.out.println("thread interupted");  
       }  
     }  
   }  
 }  
 class thread2 extends Thread {  
   @Override  
   public void run() {  
     for (int i = 0; i < 100; i++) {  
       System.out.println("thread 2 running "+ i);  
       try {  
         Thread.sleep(500);  
       } catch (InterruptedException IE) {  
         System.out.println("thread interupted");  
       }  
     }  
     System.out.println("thread 2 complete");  
   }  
 }  

meng-implements interface Runnable

 public class tryClass {  
   public static void main (String [] args) {  
     thread1 th1 = new thread1();  
     thread2 th2 = new thread2();  
     Thread T1 = new Thread(th1);  
     Thread T2 = new Thread(th2);  
     T1.start();  
     T2.start();  
   }  
 }  
 class thread1 implements Runnable {  
   @Override  
   public void run() {  
     while (true) {  
       System.out.println("thread 1 running");  
       try {  
         Thread.sleep(1000);  
       } catch (InterruptedException IE) {  
         System.out.println("thread interupted");  
       }  
     }  
   }  
 }  
 class thread2 implements Runnable {  
   @Override  
   public void run() {  
     for (int i = 0; i < 100; i++) {  
       System.out.println("thread 2 running "+ i);  
       try {  
         Thread.sleep(500);  
       } catch (InterruptedException IE) {  
         System.out.println("thread interupted");  
       }  
     }  
     System.out.println("thread 2 complete");  
   }  
 }  

mengenai cara mana yang lebih baik (antara cara 1 dan 2), semuanya tergantung kepada kebutuhan programmer.
kalo ada kesalahan mohon dikoreksi :)
semoga bermanfaat..