Home > Pemrograman Java > Java: Memulai Pemrograman Multithreading

Java: Memulai Pemrograman Multithreading


Multithreading mengacu kepada dua atau lebih task (tugas, thread) yang berjalan (sedang dieksekusi) di dalam satu program. Thread merupakan suatu path eksekusi independen di dalam program. Banyak thread dapat nerjalan secara konkuren (berbarengan) di dalam program. Setiap thread di dalam Java dibuat dan dikendalikan oleh kelas java.lang.Thread. Suatu program Java dapat mempunyai banyak thread, dan thread-thread ini dapat berjalan secara bersamaan, secara asinkron atau sinkron.

Multithreading mempunyai beberapa keuntungan, dibandingkan multiprocessing, di antaranya:

  • Thread bersifat lightweight, sedangkan proses lebih berat. Perlu diketahui bahwa proses adalah program yang sedang berada di memory atau processor, sedang dieksekusi. Thread dapat diartikan sebagai anak dari proses.
  • Thread-thread berbagi pakai ruang alamat yang sama dan karena itu dapat berbagi pakai data dan kode (instruksi)
  • Context switching antar thread biasanya lebih murah daripada antar proses.
  • Biaya komunikasi antar thread relatif lebih rendah daripada komunikasi antar proses.
  • Thread memungkinkan task-task berbeda dikerjakan secara konkuren.

Note: Penjelasan lebih detail mengenai konsep thread dan proses dapat dibaca pada buku teks mengenai Sistem Operasi, di antaranya karya Stallings dan Tanenbaum yang banyak digunakan di Universitas di Dunia.

Kelas Thread merupakan turunan dari kelas Object. Kelas Object sendiri mempunyai metode notify(), notifyAll() dan wait(), sedangkan kelas Thread menyediakan metode sleep() dan yield(). Metode-metode ini akan sering digunakan dalam pengelolaan aplikasi banyak thread.

Pembuatan Thread

Terdapat 2 (dua) cara membuat thread di dalam Java:

  • Mengimplementasikan interface Runnable (java.lang.Runnable)
  • Menurunkan (extend) kelas Thread (java.lang.Thread)

Mengimplementasikan Interface Runnable

Bentuk dasar (signature) dari interface Runnable adalah

public interface Runnable {
    void run();
}

Pada pendekatan ini, kita harus membuat sebuah kelas yang implementasi interface Runnable menggunakan kata kunci implements Runnable. Kemudian dibuat instansiasi berupa suatu obyek dari kelas itu. Kita perlu meng-override metode run() di dalam kelas itu, satu-satunya metode yang perlu diimplementasikan. Metode run() mengandung logika dari thread yang dibangun.

Prosedur pembuatan thread berdasarkan pendekatan interface Runnable adalah sebagai berikut:

  1. Sebuah kelas meng-implements interface Runnable, menyediakan metode run() di dalamnya yang akan dieksekusi oleh thread nantinya. Obyek dari kelas ini merupakan obyek Runnable.
  2. Obyek dari kelas Thread dibuat dengan melewatkan obyek Runnable sebagai argumen ke konstruktur Thread. Obyek Thread sekarang mempunyai suatu obyek Runnable yang mengimplementasikan metode run().
  3. Metode start() pada obyek Thread yang dibuat sebelumnya dipanggil. Metode start() tersebut kembali segera setelah suatu thread dilahirkan (berhasil dibuat).
  4. Thread berakhir ketika metode run() berakhir, baik dengan penyelesaian normal atau dengan melempar suatu eksepsi tidak tertangkap (uncaught exception).

Di bawah ini adalah sebuah program yang mengilustrasikan pembuatan thread menggunakan interfaca Runnable, bukan meng-extend kelas Thread. Suatu thread dimulai ketika kita memanggil metode start() pada obyek yang dibuat.


class RunnableThread implements Runnable {

	Thread runner;

	public RunnableThread() {	}

	public RunnableThread(String threadName) {
		runner = new Thread(this, threadName); // (1) Buat thread baru.
		System.out.println(runner.getName());
		runner.start(); // (2) Memulai eksekusi thread tersebut.
	}

	public void run() {
		//Tampilkan info tentang thread ini
		System.out.println(Thread.currentThread());
	}
}

public class RunnableExample {

	public static void main(String[] args) {
		Thread thread1 = new Thread(new RunnableThread(), "thread1");
		Thread thread2 = new Thread(new RunnableThread(), "thread2");
		RunnableThread thread3 = new RunnableThread("thread3");

		//Memulai eksekusi thread.
		thread1.start();
		thread2.start();
		try {
			//delay selama satu detik (1000 ms).
			Thread.currentThread().sleep(1000);
		} catch (InterruptedException e) {   }

		//Tampilkan info tentang thread main (utama).
		System.out.println(Thread.currentThread());
	}
}

Keluaran dari Program di atas dapat berupa:

thread3
Thread[thread1,5,main]
Thread[thread2,5,main]
Thread[thread3,5,main]
Thread[main,5,main]private

Pendekatan ini harus digunakan jika kelas yang menginstansiasi obyek thread diperlukan (sebagai parent) untuk membuat kelas-kelas lain yang merupakan keturunannya. Pada kasus demikian, kita tidak boleh menurunkan kelas Thread, harus mengimplementasikan Runnable.

Meng-Extend Kelas Thread

Prosedur pembuatan thread melalui pendekatan penurunan kelas Thread adalah sebagai berikut:

  1. Membuat sebuah sub-kelas turunan dari kelas Thread, kemudian meng-override metode run() dari kelas Thread dan di dalamnya didefinisikan beberapa kode yang dieksekusi oleh thread.
  2. Sub-kelas ini dapat memanggil suatu konstruktur Thread secara eksplisit untuk menginisialisasi thread, menggunakan metode super().
  3. Metode start() yang telah diturunkan (secara otomatis) dari kelas Thread dipanggil agar thread segera berjalan.

Berikut ini adalah sebuah program yang mengilustrasikan pembuatan thread dengan meng-extend kelas Thread sebagai ganti mengimplementasikan interface Runnable. Metode start() digunakanuntuk mengeksekusi obyek thread yang dibuat.


class XThread extends Thread {

	XThread() {  }

	XThread(String threadName) {
		super(threadName); // Memulai thread.
		System.out.println(this);
		start();
	}

	public void run() {
		//Tampilkan info tentang thread ini
		System.out.println(Thread.currentThread().getName());
	}
}

public class ThreadExample {

	public static void main(String[] args) {
		Thread thread1 = new Thread(new XThread(), "thread1");
		Thread thread2 = new Thread(new XThread(), "thread2");

		// 2 thread diberikan nama default
		Thread thread3 = new XThread();
		Thread thread4 = new XThread();
		Thread thread5 = new XThread("thread5");

		//Memulai eksekusi thread
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
		try {
	//Metode sleep() dipanggil pada thred main (utama), delay 1 detik.
			Thread.currentThread().sleep(1000);
		} catch (InterruptedException e) {	}

		//Tampilkan info tentang thread main
		System.out.println(Thread.currentThread());
	}
}

Keluaran yang diperoleh dapat berupa:

Thread[thread5,5,main]
thread1
thread5
thread2
Thread-3
Thread-2
Thread[main,5,main]

Pada saat membuat thread, ada dua alasan mengapa kita mengimplementasikan interface Runnable, bukan meng-extend kelas Thread:

  • Menurunkan kelas Thread berarti bahwa subclass tidak dapat diturunkan menjadi kelas lain lagi, sedangkan suatu kelas yang mengimplementasikan interface Runnable mempunyai opsi ini.
  • Suatu kelas mungkin hanya diinginkan runnable, karena itu menurunkan Thread secara penuh merupakan pemborosan.

Contoh dari kelas anonim berikut memperlihatkan bagaimana membuat sebuah thread dan langsung menjalankannya:


( new Thread() {
   public void run() {
      for(;;) System.out.println(”Stop the world!”);
   }
}
).start();

Masih banyak fitur lain di Java yang dapat digunakan untuk mengelola thread. Insya Allah coba dibahas pada tulisan berikutnya.

  1. Dangstars
    14 August 2009 at 2:10 am

    Artikel bermanfaat,,sangat saya butuhkan

    terimakasih telah berbagi

    sukses selalu

  2. iben
    11 September 2009 at 7:17 am

    mas cara gawe virus piye?? ewh uploadke file struktur data 1 list programe neng email q iso ra???boysben28@yahoo.co.id
    iben

  3. ryan barker
    7 November 2009 at 3:15 pm

    artikel mantap nii…

  4. Tie_wie
    8 November 2009 at 1:03 pm

    Asslm…mas.. Salam kenal mas..,,
    Mas pernah bikin aplikasi email client untuk perangkat mobile g mas..???
    aq lg bkin tugas akhir itu, tp aq sm skl blm bel j2me…

    trus klo ada referensi untuk aplikasi mobile sepert itu tolong dikiram ke email aq y mas..^^

    Makasih byk mas…Wasslm…

  5. 12 November 2009 at 2:00 am

    wah tau gini…mendingan pindah ke java dari dulu kali yaw…………..
    banyak comunitynya ik?????

  6. satriya teguh
    27 November 2009 at 2:45 am

    mas,
    klo aplikasi java misal client jetik salam
    server jawab otomatis hallo.. dll
    tp dg multi thread gmn carannya…..
    banyak client….

  7. 16 September 2010 at 1:25 pm

    ada tutorial pdfnya atau yang lain gak pak, dimana saya bisa download?atau bisa gak saya dikirimi. saya tertarik sekali belajar itu. dan keuanggulannya apa saja yaaa?

  8. Rizqi
    14 October 2010 at 10:19 am

    bisa gak ditambahin method lain di klas thread??

  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: