Home > Pemrograman Java, Sistem Terdistribusi > Multithreading di Java (4)

Multithreading di Java (4)


Ada dua cara untuk menentukan kode apa yang akan dieksekusi oleh thread. Pertama adalah membuat suatu subclass dari Thread dan meng-overide metode run(). Cara kedua adalah dengan melewatkan suatu obyek yang mengimplementasikan Runnable ke konstruktor Thread.

4. Membuat dan Memulai Thread


Thread Java adalah obyek sebagaimana obyek Java yang lain. Thread merupakan instance dari kelas java.lang.Thread, atau instance dari subclass dari kelas ini.

Pembuatan suatu thread dalam Java dilakukan seperti ini:

Thread thread = new Thread();

Dan untuk memulai thread tersebut kita memanggil metode start()-nya, seperti ini:

thread.start();

Contoh ini tidak menetapkan kode yang akan dieksekusi oleh thread. Thread akan segera berhenti.
Ada dua cara untuk menentukan kode apa yang akan dieksekusi oleh thread. Pertama adalah membuat suatu subclass dari Thread dan meng-overide metode run(). Cara kedua adalah dengan melewatkan suatu obyek yang mengimplementasikan Runnable ke konstruktor Thread. Kedua cara tersebut akan dibahas di bawah ini.

Sub-class Thread
Cara pertama menentukan kode apa yang akan dijalankan oleh thread adalah dengan membuat suatu subclass dari Thread dan meng-override metode run(). Metode run() mengandung apa yang akan dieksekusi oleh thread setelah kita memanggil start(). Berikut ini adalah contohnya::

public class MyThread extends Thread {

public void run(){
System.out.println(“MyThread running…”);
}
}

Sedangkan untuk membuat dan memulai thread di atas kita dapat menggunaan kode seperti berikut:

MyThread myThread = new MyThread();
myThread.start();

Pemanggilan start() akan segera mengembalikan thread yang dimulai, tidak akan menunggu sampai metode run() selesai dikerjakan. Metode run() akan berjalan seperti dieksekusi oleh CPU berbeda. Pada saat metode run() berjalan maka ia akan mencetak teks “MyThread running…”.

Kita dapat juga membuat sebuah subclass anonymous dari Thread seperti ini:

Thread thread = new Thread(){
public void run(){
System.out.println(“Thread Running…”);
}
}

thread.start();

Contoh ini akan mencetak teks “Thread running…” setelah metode run() dieksekusi oleh thread baru.

Implementasi Runnable
Cara kedua menentukan kode apa yang akan dijalankan oleh thread adalah dengan membuat suatu kelas yang mengimplementasikan java.lang.Runnable. Obyek Runnable dapat dieksekusi oleh suatu Thread.

Berikut ini adalah bagaimana cara ini diterapkan:

public class MyRunnable implements Runnable {

public void run(){
System.out.println(“MyRunnable running…”);
}
}

Agar metode run() dieksekusi oleh thread, lewatkan suatu instance dari MyRunnable ke thread dalam konstruktornya. Berikut ini adalah bagaimana itu dilakukan:

Thread thread = new Thread(new MyRunnable());
thread.start();

Ketika thread dimulai maka ia akan memanggil metode run() dari instance MyRunnable sebagai ganti mengeksekusi metode run()nya sendiri. Contoh di atas akan mencetak teks “MyRunnable running…”.
Kita dapat pula membuat implementasi anonymous dari Runnable, seperti ini:

Runnable myRunnable = new Runnable(){

public void run(){
System.out.println(“Runnable running…”);
}
}

Thread thread = new Thread(myRunnable);
thread.start();

Subclass atau Runnable?
Tidak ada aturan mengenai mana yang terbaik. Kedua metode bekerja dengan baik. Sebagian pemrogram lebih suka mengimplementasikan Runnable dan menyerahkan instance dari implementasi tersebut ke suatu instance Thread. Ketika berharap Runnable dieksekusi oleh suatu thread pool maka kita dapat dengan mudah mengantrikan instance Runnable sampai thread dari pool menganggur (idle). Sedikit lebih sulit melakukan ini dengan subclass Thread.

Kadangkala kita mungkin harus mengimplementasikan Runnable sebagaimana juga subclass Thread. Sebagai contoh, jika membuat suatu subclass dari Thread yang dapat mengeksekusi lebih dari satu Runnable. Ini biasanya kasus ketika mengimplementasikan suatu thread pool.

Perangkap: Memanggil run(), bukan start()
Ketika membuat dan memulai suatu thread, kesalahan umum yang sering dilakukan adalah memanggil metode run() dari Thread, bukan memanggil metode start(), misalnya:

Thread newThread = new Thread(MyRunnable());
thread.run(); // harusnya start();

Pada waktu pertama mungkin kita tidak menemukan apapun karena metode run() dari Runnable dieksekusi seperti diharapkan. Namun, metode tersebut tidaklah dieksekusi oleh thread baru yang baru saja dibuat. Malah metode run() dieksekusi oleh thread yang membuat thread baru. Dengan kata lain, thread tersebut yang mengeksekusi dua baris kode di atas. Agar metode run() dari instance MyRunnable dipanggil oleh thread yang baru dibuat, newThread, kita harus memanggil metode newThread.start().

Nama Thread
Saat membuat suatu thread kita dapat memberikannya suatu nama. Nama dapat membantu kita membedakan thread-thread berbeda satu dengan lainnya. Sebagai contoh, jika banyak thread menulis ke System.out maka kita dapat dengan mudah mengetahui thread mana yang menuliskan teks. Berikut adalah contohnya:

Thread thread = new Thread(“New Thread”) {
public void run(){
System.out.println(“run by: ” + getname());
}
};

thread.start();
System.out.println(thread.getName());

Perhatikan string “New Thread” yang dilewatkan sebagai parameter ke konstruktor Thread. String ini adalah nama dari thread. Nama tersebut dapat diperoleh dengan memanggil metode getName() dari Thread. Kita juga dapat melewatkan nama ke suatu Thread ketika menggunakan implementasi Runnable. Kode berikut memperlihatkan caranya:

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable, “New Thread”);

thread.start();
System.out.println(thread.getName());

Namun, karena kelas MyRunnable bukanlah subclass dari Thread maka kelas tersebut tidak mempunyai akses ke metode getName() dari thread yang mengeksekusinya. Suatu referensi ke thread yang sedang berjalan (mengeksekusi) dapat diperoleh dengan memanggil

Thread.currentThread();

Karena itu nama dari thread yang sedang mengeksekusi kode dapat diperoleh dengan cara:

String threadName = Thread.currentThread().getName();

Contoh Thread
Di bawah ini adalah contoh kecil thread dalam kode kelas yang lengkap. Pertama, program mencetak nama dari thread yang mengeksekusi metode main(). Thread ini di-assign oleh JVM (Java Virtual Machine). Kemudian memulai 10 thread dan memberikan bilangan sebagai nama (“” + i). Setiap thread kemudian mencetak namanya, dan kemudian menghentikan eksekusi.

public class ThreadExample {

public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
for(int i=0; i<10; i++){
new Thread(“” + i){
public void run(){
System.out.println(“Thread: ” + getName() + ” running…”);
}
}.start();
}
}
}

Perhatikan, meskipun thread-thread dimulai dalam bentuk terurut (1, 2, 3 dst.) namun eksekusi dapat terjadi tidak secara sequential, berarti thread 1 mungkin bukanlah thread pertama yang menuliskan namanya ke System.out. Ini karena thread-thread secara prinsip dieksekusi secara paralel dan tidak terurut. JVM dan/atau sistem operasi menentukan urutan eksekusi thread-thread. Urutan ini tidak harus sama dengan urutan thread-thread dimulai.

  1. No comments yet.
  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: