THREAD

Thread adalah rangkaian eksekusi dari sebuah aplikasi java dan setiap program java
minimal memiliki satu buah thread. Sebuah thread bisa berada di salah satu dari 4 status,
yaitu new, runnable, blocked, dan dead.
A.    Status Thread
            1.     New
      Thread yang berada di status ini adalah objek dari kelas Thread yang baru dibuat, yaitu
saat instansiasi objek dengan statement new. Saat thread berada di status new,belum ada
sumber daya yang dialokasikan, sehingga thread belum bisa menjalankan perintah apapun.
            2.     Runnable
       Agar thread bisa menjalankan tugasnya, method start() dari kelas Thread harus dipanggil.
Ada dua hal yang terjadi saat pemanggilan method start(), yaitu alokasi memori untuk thread
yang dibuat dan pemanggilan method run(). Saat method run() dipanggil, status thread
berubah menjadi runnable, artinya thread tersebut sudah memenuhi syarat untuk dijalankan
oleh JVM. Thread yang sedang berjalan juga berada di status runnable.
            3.     Blocked
       Sebuah thread dikatakan berstatus blocked atau terhalang jika terjadi blocking statement,
misalnya pemanggilan method sleep(). sleep() adalah suatu method yang menerima argumen
bertipe integer dalam bentuk milisekon. Argumen tersebut menunjukkan seberapa lama
thread akan “tidur”. Selain sleep(), dulunya dikenal method suspend(), tetapi sudah
disarankan untuk tidak digunakan lagi karena mengakibatkan terjadinya deadlock. Thread
akan menjadi runnable kembali jika interval method sleep()-nya sudah berakhir, atau
pemanggilan method resume() jika untuk menghalangi thread tadi digunakan method
suspend()
            4.     Dead
        Sebuah thread berada di status dead bila telah keluar dari method run(). Hal ini bisa
terjadi karena thread tersebut memang telah menyelesaikan pekerjaannya di method run(),
maupun karena adanya pembatalan thread. Status jelas dari sebuah thread tidak dapat
diketahui, tetapi method isAlive() mengembalikan nilai boolean untuk mengetahui apakah
thread tersebut dead atau tidak.

         B.    Pembentukan Thread dalam java

         Untuk membuat thread dalam java terdapat dua cara :
            a.     Extends class Thread
       Untuk menjalankan thread, dapat dilakukan dengan memanggil method start(). Saat
start() dijalankan, maka sebenarnya method run() dari class akan dijalankan. Jadi untuk
 membuat thread, harus mendefinisikan method run() pada definisi class. Konstruktor dari
cara ini adalah:
SubThread namaObject = new SubThread();
namaObject.start();
            b.     Implements interface Runnable
   Cara ini merupakan cara yang paling sederhana dalam membuat thread. Runnable
merupakan unit abstrak, yaitu kelas yang mengimplementasikan interface ini hanya cukup
mengimplementasikan fungsi run(). Dalam mengimplementasi fungsi run(), kita akan
mendefinisikan instruksi yang membangun sebuah thread. Konstruktor dari cara ini adalah :
MyThread myObject= new MyThread();
Thread namaObject = new Thread(myObject);
Atau dengan cara singkat seperti :
New Thread(new ObjekRunnable());
MyThread merupakan class yang mengimplementasikan interface dari Runnable, dan object
dari class MyThread akan menjadi parameter instansi object class Thread.
            c.     Synchronized
  Sinkronisasi adalah method atau blok yang memiliki tambahan keyword
synchronized,sehingga apabila dijalankan maka hanya satu thread pada suatu waktu yang
dapat menjalankan method atau blok program. Thread lain akan menunggu thread yang
sedang mengeksekusi method ini hingga selesai. Mekanisme sinkronisasi penting apabila
terjadi pembagian sumber daya maupun data di antara thread-thread. Sinkronisasi juga
melakukan penguncian pada sumber daya atau data yang sedang diproses.
Sinkronisasi dapat dilakukan pada dua bagian yaitu
1.     Sinkronisasi Blok
Sintak untuk sinkronisasi blok adalah sebagai berikut :
synchronized (<object reference expression>) {
<code block>
}
2.     Sinkronisasi Method
Sintak untuk sinkronisasi method adalah sebagai berikut:
synchronized TypeBalikanMethod NamaMethod ( parameter)
{
}
    C.    Prioritas Thread
     Dalam Java kita dapat membuat prioritas suatu thread relative terhadapa thread yang lain.
Sehingga thread yang mempunyai prioritas lebih tinggi mempunyai kesempatan lebih besar
untuk mengakses suatu sources
       Java Virtual Machine memilih thread yang runnable dengan prioritas tertinggi. Semua
thread java mempunyai prioritas dari 1 sampai 10. Prioritas tertinggi 10 dan berakhir dengan
1 sebagai prioritas terendah. Sedangkan prioritas normal adalah 5.
Thread.MIN_PRIORITY = thread dengan prioritas terendah.
Thread.MAX_PRIORITY = thread dengan prioritas tertinggi.
Thread.NORM_PRIORITY = thread dengan prioritas normal.
       Saat thread baru dibuat ia mempunyai prioritas yang sama dengan thread yang
menciptakannya. Prioritas thread dapat diubah dengan menggunakan setpriority() method.
    D.    Obyek Thread

      Thread hanya bisa digunakan dalam sebuah aplikasi tidak bisa berdiri menjadi sebuah
obyek tersendiri. Java runtime menghubungkan setiap live thread sebagai instance dari
kelas java.lang.Thread. Kelas inilah yang digunakan untuk menjalankan thread baru serta
mengambil dan mengeset prioritas dari thread itu sendiri. Pada J2ME Thread hanya
mendukung method-method berikut:

 activeCount()
Mengembalikan nilai sekarang yang aktif pada virtual mesin.

 currentThread()
Akan mengembalikan nilai object uang sekarang.

 getPriority()
Akan mengembalikan Prioritas thread.

 isAlive()
Mengecek aktifnya thread.
       join()
Menuggu hingga thread ini selesai.
       run()
jika thread ini dibangun harus menggunakan implementasi Runnable dan menyantumkan
object run maka otomatis object Runable akan memanggil method run.

 setPriority()
Merubah prioritas pada thread ini.

 sleep()
Untuk melaksanakan berhenti sementara dalam betuk milidetik.

 start()
 Thread ini mengawali eksekusi.

 yield()
Thread ini untuk menunda dan mengijinkan thread lain untuk mengeksekusi.

 Menggunakan Thread
Untuk diketahui, ada 2 cara dalam menggunakan class Thread ini:
1.     Mendeklarasikan sebuah kelas yang menjadi turunan dari kelas Thread.
       Sub kelas yang dibuat harus mengoverride method run dari kelas Thread, baru kemudian
kita bisa membuat sebuah instance dari kelas tersebut untuk dialokasikan dan dijalankan.
Berikut contoh Thread yang akan melakukan penghitungan scoring.

class ThreadSkoring extends Thread {

ThreadSkoring() {

public void run() {

// operasi menghitung skor game

...

Pendeklarasian Class : 
Membuat obyek ThreadSkoring dan menjalankannya:

ThreadSkoring p = new ThreadSkoring();

p.start();

      2.     Mendeklarasikan sebuah kelas yang mengimplementasikan interface Runnable.

        Kelas baru yang dibuat harus mengoverride method run dari kelas Runnable, baru
kemudian sebuah instance dari kelas tersebut bisa dialokasikan dan dijalankan melalui
argumen saat membuat obyek baru dari kelas Thread.
Pendeklarasian kelas:

class RunSkoring extends Thread {

RunSkoring() {

public void run() {

// operasi menghitung skor game

...

Membuat obyek RunSkoring dan menjalankannya:

RunSkoring p = new RunSkoring();

new Thread(p).start();

3.     Menghentikan Thread
          Setelah melihat daftar method-method Thread yang didukung pada J2ME di
atas, tampak tidak terdapat method stop() dan interrupt(). Keduanya didukung pada
J2SE, namun karena konfigurasi J2ME yang minim, keduanya tidak didukung.
Method stop() telah dihilangkan karena inherently unreliable dan tidak bisa
diimplementasikan pada semua platform dengan aman dan konsisten. Sedangkan
method interrupt() sudah diperkenalkan lagi pada CLDC versi 1.1 dan sepertinya
akan segera diperkenalkan juga pada CDC revisi berikutnya.
Oleh karena itu, agar thread yang kita buat dan jalankan bisa berhenti, maka kita
perlu memberikan flag agar tiap-tiap live thread bisa menghentikan dirinya sendiri.
Flag ini sangat penting didefinisikan untuk setiap thread pada sebuah aplikasi agar
bisa menghentikan dirinya sendiri. Cara paling mudah ialah agar thread secara
periodik memeriksa sebuah variabel flag untuk menentukan dirinya berjalan terus
atau sudah harus berhenti. Misalnya dengan mendefinisikan sebuah kelas
MyThread sebagai berikut:

public class MyThread implements Runnable {

private boolean selesai = false;

public void run(){

while( !selesai ){

// lakukan operasi yang diperlukan

public void selesai(){

selesai = true;

Kelas di atas akan terus melakukan operasi pada method run() sampai kita

memanggil method selesai() yang sudah kita definisikan di dalam kelas itu.