Pendahuluan
Suatu proses dikontrol oleh paling sedikit satu thread. Namun, sebagian besar proses yang ada sekarang biasanya dijalankan oleh beberapa buah thread. Multithreading adalah sebuah mekanisme di mana dalam suatu proses, ada beberapa thread yang mengerjakan tugasnya masing-masing pada waktu yang bersamaan. Contohnya, sebuah web browser harus menampilkan sebuah halaman yang memuat banyak gambar. Pada program yang single-threaded, hanya ada satu thread untuk mengatur suatu gambar, lalu jika gambar itu telah ditampilkan, barulah gambar lain bisa diproses. Dengan multithreading, proses bisa dilakukan lebih cepat jika ada thread yang menampilkan gambar pertama, lalu thread lain untuk menampilkan gambar kedua, dan seterusnya, di mana thread-thread tersebut berjalan secara paralel.
Saat sebuah program Java dieksekusi, yaitu saat
main() dijalankan, ada sebuah thread utama yang bekerja. Java adalah bahasa pemrograman yang mendukung adanya pembentukan thread tambahan selain thread utama tersebut. Thread dalam Java diatur oleh Java Virtual Machine(JVM) sehingga sulit untuk menentukan apakah thread Java berada di user-level atau kernel-level.Status Thread
 |
Suatu thread bisa berada pada salah satu dari status berikut:
· 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.
· 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.
· 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. Di samping blocking statement, adanya interupsi M/K juga dapat menyebabkan thread menjadi blocked. Thread akan menjadi runnable kembali jika interval method sleep()-nya sudah berakhir, atau pemanggilan method resume() jika untuk menghalangi thread tadi digunakan method suspend() atau M/K sudah tersedia lagi.
· 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.
Pembentukan Thread
a. Extends kelas Thread
b. 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()
{
for (int ii = 0; ii<4; ii++){
System.out.println("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()
{
for(int ii = 0; ii<4; ii++){
System.out.println("Ini CobaThread2");
Test.istirohat(7);
}
}
public class Test
{
public static void main (String[] args)
{
Thread t1 = new CobaThread1();
Thread t2 = new Thread (new CobaThread2());
t1.start();
t2.start();
for (int ii = 0; ii<8; ii++){
System.out.println("Thread UTAMA");
istirohat(5);
}
}
public static void istirohat(int tunda)
{
try{
Thread.sleep(tunda*100);
} catch(InterruptedException e) {}
}
}
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 pada constructor-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{ t1.join(); } 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 dan deferred cancellation. Pada asynchoronous cancellation, sebuah thread langsung menterminasi target thread, sedangkan pada deferred cancellation, target thread secara berkala memeriksa apakah ia harus terminate 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 terjadinya exception 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(){ while (true){ System.out.println("saya thread CobaThread3"); if (Thread.currentThread.isInterrupted()) //cek status break; } }} Suatu thread dari kelas
CobaThread3 dapat diinterupsi dengan kode berikut: Thread targetThread = new Thread (new CobaThread3());targetThread.start();targetThread.interrupt(); //set status interupsi 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 method run(), 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 diperkenalkan package java.nio yang mendukung interupsi thread yang sedang melakukan operasi M/K.JVM
Setiap program Java dijalankan oleh Java Virtual Machine(JVM). Artinya, program Java dapat dijalankan di platform manapun selama platform tersebut mendukung JVM. Umumnya JVM diimplementasikan di bagian atas suatu host operating system, hal ini memungkinkan JVM untuk menyembunyikan detail implementasi dari sistem operasi tersebut.
Pemetaan thread Java ke suatu sistem operasi tergantung pada implementasi JVM pada sistem operasi itu. Misalnya, Windows 2000 menggunakan model one-to-one, Solaris dulunya menggunakan model many-to-one, sedangkan Tru64 UNIX menggunakan model many-to-many.
Aplikasi Thread dalam Java
Dalam ilustrasi program yang ada pada subbab “Pembatalan Thread”, kita tidak dapat mengetahui thread yang mana yang akan terlebih dahulu mengerjakan tugasnya. Hal ini terjadi karena ada dua thread yang berjalan secara paralel, yaitu thread utama dan thread t1. Artinya, keluaran dari program ini bisa bervariasi. Salah satu kemungkinan keluaran program ini adalah sebagai berikut:
Thread UTAMAIni CobaThread1Ini CobaThread2Thread UTAMAIni CobaThread2Thread UTAMAIni CobaThread1Ini CobaThread2Thread UTAMAThread UTAMAIni CobaThread2Ini CobaThread1Thread UTAMAThread UTAMAIni CobaThread1Thread UTAMARangkuman
Setiap program Java memiliki paling sedikit satu thread. Bahasa pemrograman Java memungkinkan adanya pembuatan dan manajemen thread tambahan oleh JVM. Sebuah thread bisa berada di salah satu dari 4 status, yaitu new, runnable, blocked, dan dead. Ada dua cara untuk membuat thread dalam Java, yaitu dengan meng- extends kelas
Thread dan dengan meng- implements interface Runnable.Dalam beberapa kondisi, thread yang dibuat dapat digabungkan dengan parent thread-nya. Method
join() berfungsi agar suatu thread menunggu thread yang dibuatnya menyelesaikan tugasnya terlebih dahulu, baru mulai mengeksekusi perintah selanjutnya.Pembatalan thread secara asynchronous dilakukan dengan pemanggilan method
stop(). Akan tetapi, cara ini terbukti tidak aman, sehingga untuk menterminasi thread digunakanlah deferred cancellation. Pembatalan dilakukan dengan pemanggilan method interrupt() untuk mengeset status interupsi, serta isInterrupted() atau interrupted() untuk memeriksa status interupsi tersebut.Program Java dapat dijalankan di berbagai platform selama platform tersebut mendukung JVM. Pemetaan thread Java ke host operating system tergantung pada implementasi JVM di sistem operasi tersebut.
sumber
Tidak ada komentar:
Posting Komentar