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>
}
<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.