Materi Thread ini berasal dari websitenya catatan.desdrianton.net
Materi ini memiliki kenangan tersendiri bagi saya karena melalui catatan.desdrianton.net ini saya mengerti konsep Thread pada tahun 2012.
Thread = worker
Jobs = urutan pekerjaan (thread of execution)
*Baca= Thread mengeksekusi jobs
Thread = worker
Jobs = urutan pekerjaan (thread of execution)
*Baca= Thread mengeksekusi jobs
Karena catatan ini telah membantu saya, lalu saya simpan hingga saat ini saya mengulang materi dan kembali membacanya. Namun, sayang, ketika hari ini saya searching di google, website catatan.desdrianton.net tidak ditemukan padahal banyak sekali buku praktikum, tugas akhir, weblog hingga website perkuliahaan perguruan tinggi mengambil web catatan.desdrianton.net sebagai sumber referensi dalam pembelajaran Java dasar.
Harapan saya, mudah2an penulis catatan.desdrianton.net kembali meng-onlinekan blog-nya agar pembelajar-pembelajar Java khususnya pemula dapat mengambil manfaat.
Anyway, terima kasih catatan.desdrianton.net berkat kamu, saya mengerti Thread!
Note: ini bukti saya menyimpan, materi threads dari web catatan.desdrianton.net.
------------------------------------------------------------------
THREADS
OBJECTIVE
|
· Thread dalam java memiliki 2 buah pengertian, yaitu [1]:
1. Instance dari class java.lang.Thread
2. Urutan eksekusi (thread of execution)
· Untuk memudahkan pemahaman tentang thread, selalulah berpikiran bahwa urutan eksekusi (thread of execution) yang hendak dikerjakan sebagai job (pekerjaan). Sedangkan instance dari classjava.lang.Thread adalah worker (pekerja) yang mengerjakan job. Pekerja mengerjakan pekerjaan.
· Support terhadap thread dalam java disediakan oleh 2 buah kelas, dan sebuah interface berikut [2]:
1. Interface java.lang.Runnable
2. Kelas java.lang.Thread (kelas ini meng-implements interface java.lang.Runnable)
3. Kelas java.lang.Object
· Interface java.lang.Runnable hanya memiliki sebuah method abstract, yaitu [3]: public abstract void run().
· Method dan constructor kelas java.lang.Thread yang sering dipakai [3] :
1. public Thread()
2. public Thread(java.lang.Runnable target)
3. public Thread(java.lang.String threadName)
4. public Thread(java.lang.Runnable target, java.lang.String threadName)
5. public synchronized void start()
6. public void run()
7. public static void sleep(long milisecond)
8. public static native void yield()
9. public final native boolean isAlive()
10. public final void setName(String namaThread)
11. public final String getName()
12. public static native java.lang.Thread currentThread()
13. public final void join() throws InterruptedException
14. public final void join(long milisecond) throws InterruptedException
15. public final void setPriority(int newPriority)
16. public final int getPriority()
· Method dari kelas java.lang.Object yang sering dipakai dalam hubungannya dengan pengaturan thread adalah :
1. public final native void notify()
2. public final native void notifyAll()
3. public final native void wait() throws InterruptedException
· Setiap aplikasi java paling tidak memiliki sebuah thread [2]. Setiap thread dapat memiliki nama. Bila sebuah thread tidak diberi nama, maka nama default untuk thread adalah Thread-0, Thread-1, dst. Khusus untuk class yang memiliki method public static void main(String[]) yang dijalanakan, maka thread yang menjalankannya disebut diberi nama main.
Listing 1 : NamaThreadMain.java
|
package thread;
public class NamaThreadMain {
public static void main(String[] args) {
String namaThread = Thread.currentThread().getName();
System.out.println("Nama thread ini adalah : " +
namaThread);
}
}
|
Listing program di atas akan menghasilkan :
Nama thread ini adalah : main
|
· Java memiliki 2 jenis thread, yaitu :
1. User thread
2. Daemon thread
· Perbedaan antara user thread dan daemon thread adalah bila pada user thread JVM akan selesai (shutdown) bila semua user thread telah selesai, sedangkan pada daemon thread tidak. Jenis thread ini tidak termasuk dalam exam [1].
1. Thread Scheduler
· Thread scheduler adalah bagian dari JVM yang berfungsi untuk mengatur thread mana yang berjalan [1].
· Algoritma scheduling yang digunakan oleh tiap JVM berbeda-beda (dan platform dependent), 2 algoritma scheduling utama adalah :
1. Preemptive scheduling
2. Time sharing
· Pada algoritma preemptive scheduling, tiap thread memiliki prioritas. Thread dengan prioritas lebih tinggi memiliki kesempatan yang lebih besar untuk memasuki state running [2].
· Pada algoritma time sharing, suatu thread berada dalam state running dalam jangka waktu tertentu. Setelah jangka waktu tersebut habis, thread kembali ke state runnable [2].
· Thread scheduler pula yang bertugas untuk membawa suatu thread dari state runnable ke state running dan sebaliknya (state running ke state runnable) [1].
· Setiap thread yang berada dalam state runnable dapat dipilih oleh thread scheduler untuk memasuki state running, akan tetapi tidak ada kepastian thread mana yang akan dipilih oleh scheduller [1].
· Dalam satu satuan waktu, hanya ada satu buah thread yang berada dalam state running (dan itu ditentukan oleh thread scheduler) [1].
2. Define, Instantiate, dan Starting Thread
· Thread dapat dibuat dengan salah satu dari dua buah cara berikut [2] :
1. Meng-extends kelas java.lang.Thread
2. Meng-implements interface java.lang.Runnable
· Thread yang dibuat baik dengan cara 1 ataupun cara 2 di atas pasti merupakan instance dari kelas java.lang.Thread.
1.1 Meng-extends kelas java.lang.Thread
· Untuk menjalankan thread dengan cara ini, dibutuhkan 4 buah langkah, yaitu [2] :
1. Membuat kelas dengan men-extends kelas java.lang.Thread.
2. Mengoverride method public void run() pada kelas yang baru dibuat (membuat job).
3. Membuat object dari kelas yang baru dibuat / instansiasi (membuat worker).
4. Memulai thread dengan memanggil method start() pada object yang baru dibuat.
Listing 2 : MyThread01.java
|
package thread;
public class MyThread01
{
public static void main(String[] args)
{
System.out.println("Awal");
//Langkah 3
MyExtendsThread myThread = new MyExtendsThread();
//Langkah 4
myThread.start();
System.out.println("Akhir");
}
}
//Langkah 1
class MyExtendsThread extends Thread
{
//Langkah 2
public void run()
{
String namaThread = Thread.currentThread().getName();
for(int i = 0; i < 5; i++)
{
System.out.println(namaThread + ":" + i);
}
}
}
|
Listing program di atas akan menghasilkan :
Awal
Akhir
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
|
1.2 Meng-implements interface java.lang.Runnable
· Cara ini lebih disenangi dari pada dengan cara meng-extends kelas java.lang.Thread. Hal ini karena bila kita meng-extends kelas java.lang.Thread, maka kita tidak lagi memiliki kesempatan untuk meng-extends kelas lain.
· Untuk menjalankan thread dengan cara ini, dibutuhkan 5 buah langkah, yaitu [2] :
1. Membuat kelas yang meng-implements interface java.lang.Runnable.
2. Mengimplement method public void run() pada kelas yang baru dibuat (membuat job).
3. Membuat object dari kelas yang baru dibuat (instansiasi)
4. Membuat object dari kelas java.lang.Thread dan memasukkan object dari langkah 4 ke dalam konstruktor java.lang.Thread (membuat worker)
5. Memulai thread dengan memanggil method start() pada object dari kelas java.lang.Thread (method start() bukan dari object kelas kita, akan tetapi dari object kelas java.lang.Thread).
Listing program 3 : MyThread03
|
package thread;
public class MyThread02
{
public static void main(String[] args)
{
System.out.println("Awal");
//Langkah 3
MyImplementsRunnable myThread =
new MyImplementsRunnable();
//Langkah 4
Thread objectThread = new Thread(myThread);
//Langkah 5
objectThread.start();
System.out.println("Akhir");
}
}
//Langkah 1
class MyImplementsRunnable implements Runnable
{
//Langkah 2
public void run()
{
String namaThread = Thread.currentThread().getName();
for(int i = 0; i < 5; i++)
{
System.out.println(namaThread + ":" + i);
}
}
}
|
Listing program di atas akan menghasilkan :
Awal
Akhir
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
|
1.3 Serba-Serbi
· Untuk menjalankan sebuah thread dipergunakan method start() pada instance thread tersebut.
· Urutan eksekusi (pekerjaan / job) yang akan dijalankan sebagai thread terpisah harus berada dalam method run(). Perhatikan contoh berikut (dan simpulkan sendiri J. Clue:nama thread) :
Listing program 9 : MyThread08.java
|
package thread;
public class MyThread08
{
public static void main(String[] args)
{
SmartOne smart = new SmartOne();
StupidOne stupid = new StupidOne();
smart.start();
stupid.start();
}
}
class SmartOne extends Thread
{
public void run()
{
String namaThread = Thread.currentThread().getName();
for(int i=0; i<5; i++)
{
System.out.println(namaThread + ": " + i);
}
}
}
class StupidOne extends Thread
{
String namaThread = Thread.currentThread().getName();
public void run()
{
for(int i=0; i<5; i++)
{
System.out.println(namaThread + ": " + i);
}
}
}
|
Listing program di atas akan menghasilkan :
Thread-0: 0
Thread-0: 1
Thread-0: 2
Thread-0: 3
Thread-0: 4
main: 0
main: 1
main: 2
main: 3
main: 4
|
· Kita dapat mengoverload method run(), akan tetapi yang pasti dijalankan sebagai job adalah method dengan deklarasi sebagai berikut : public void run().
Listing program :
|
package thread;
public class JobAndWorker01
{
public static void main(String[] args)
{
OverloadRun myT = new OverloadRun();
myT.start();
}
}
class OverloadRun extends Thread
{
public void run()
{
System.out.println("run()");
}
public void run(String tulisan)
{
System.out.println("run(String)");
}
}
|
Listing program di atas akan menghasilkan :
run()
|
· Suatu thread dikatakan dalam state dead ketika method run() telah selesai dijalankan. Akan tetapi meski dalam state dead, tetap merupakan object dari java.lang.Thread (ataupunjava.lang.Runnable), sehingga method-method selain start() dapat dijalankan seperti pada object biasa [1&3].
Listing program xx :
|
package thread;
public class MyThread09
{
public static void main(String[] args)
{
SimpleThread1 threadRef = new SimpleThread1();
threadRef.start();
try
{
Thread.sleep(10);
}
catch(Exception ignore)
{
//ignore
}
threadRef.cetakTulisan();
}
}
class SimpleThread1 extends Thread
{
public void run()
{
cetakTulisan();
}
public void cetakTulisan()
{
String namaThread = Thread.currentThread().getName();
for(int i=0; i<5; i++)
{
System.out.println(namaThread + ":" + i);
}
}
}
|
Listing program di atas akan menghasilkan :
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
main:0
main:1
main:2
main:3
main:4
|
· Saat kita membuat kelas yang meng-extends kelas java.lang.Thread ataupun meng-implements interface java.lang.Runnable, maka kelas kita tersebut adalah tetap sebuah kelas biasa. Kita dapat menjalankan method run() yang telah kita override atau implement secara langsung, akan tetapi method run() tersebut tidak akan berjalan di thread baru, melainkan tetap dari thread pemanggil method run().
Listing program 4 : MyThread03.java
|
package thread;
public class MyThread03
{
public static void main(String[] args)
{
MySimpleThread myThread1 = new MySimpleThread("Ayam");
MySimpleThread myThread2 = new MySimpleThread("Bebek");
myThread1.start(); //Menghasilkan thread baru
myThread2.run();//TIDAK menghasilkan thread baru
}
}
class MySimpleThread extends Thread
{
private String mySpecialText = null;
public MySimpleThread(String mySpecialText)
{
this.mySpecialText = mySpecialText;
}
public void run()
{
String namaThread = Thread.currentThread().getName();
String tulisan = "mySpecialText : " + mySpecialText +
". Method run() ini berjalan di thread : " +
namaThread;
System.out.println(tulisan);
}
}
|
Listing program di atas akan menghasilkan :
mySpecialText : Bebek. Method run() ini berjalan di thread : main
mySpecialText : Ayam. Method run() ini berjalan di thread : Thread-0
|
· Method start() dari kelas java.lang.Thread hanya dapat dijalankan sekali. Bila lebih dari sekali akan menyebabkan exception IllegalThreadStateException.
Listing program 5 : MyThread04.java
|
package thread;
public class MyThread04
{
public static void main(String[] args)
{
MySimpleThread t1 = new MySimpleThread();
t1.start();
t1.start(); //TIDAK BOLEH
}
}
class MySimpleThread extends Thread
{
public void run()
{
String namaThread = Thread.currentThread().getName();
System.out.println(namaThread + ": method run()");
}
}
|
Listing program di atas akan menghasilkan :
Thread-0: method run()
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.start(Unknown Source)
at thread.MyThread04.main(MyThread04.java:9)
|
· Meski method start() hanya dapat dijalankan sekali, akan tetapi method run() dapat dijalankan berkali-kali.
Listing program 6: MyThread05.java
|
package thread;
public class MyThread05
{
public static void main(String[] args)
{
MySimpleThread t1 = new MySimpleThread();
t1.start();
t1.run(); //BOLEH
t1.run(); //BOLEH
}
}
class MySimpleThread extends Thread
{
public void run()
{
String namaThread = Thread.currentThread().getName();
System.out.println(namaThread + ": method run()");
}
}
|
Listing program di atas akan menghasilkan :
main: method run()
main: method run()
Thread-0: method run()
|
· Menjalankan multiple thread dari instance yang sama tergantung apakah suatu kelas meng-extends kelas java.lang.Thread atau meng-implements interface java.lang.Runnable.
Pengertian multiple thread disini adalah sebuah job dikerjakan berkali-kali secara bersamaan oleh beberapa worker.
· Bila kelas yang meng-extends kelas java.lang.Thread, maka untuk menjalankan multiple thread adalah dengan cara [3] :
1. Membuat multiple instance yang berbeda dari kelas peng-extends kelas java.lang.Thread
2. Menjalankan method start() dari tiap object (dari langkah 1).
Listing program 7 : MyTread06.java
|
package thread;
public class MyThread06
{
public static void main(String[] args)
{
//Multiple instance
SimpleThread t1 = new SimpleThread();
SimpleThread t2 = new SimpleThread();
SimpleThread t3 = new SimpleThread();
//Menjalankan method start dari tiap instance
t1.start();
t2.start();
t3.start();
}
}
class SimpleThread extends Thread
{
public void run()
{
String namaThread = Thread.currentThread().getName();
for(int i = 0; i < 5; i++)
{
System.out.println(namaThread + ":" + i);
}
}
}
|
Listing program di atas akan menghasilkan :
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-1:0
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-2:0
Thread-2:1
Thread-2:2
Thread-2:3
Thread-2:4
|
· Bila kelas meng-implements interface java.lang.Runnable, maka untuk menjalankan multiple thread dari instance kelas tersebut adalah dengan cara [2]:
1. Membuat instance (paling tidak sebuah instance) dari kelas peng-implements interface java.lang.Runnable
2. Membuat beberapa instance kelas java.lang.Thread, dan memasukkan object (dari langkah 1) ke dalam constructor kelas java.lang.Thread.
3. Menjalankan method start() dari tiap object kelas java.lang.Thread (dari langkah 2).
Listing program 8: MyThread07.java
|
package thread;
public class MyThread07
{
public static void main(String[] args)
{
SimpleThread st = new SimpleThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
Thread t3 = new Thread(st);
t1.start();
t2.start();
t3.start();
}
}
class SimpleThread implements Runnable
{
public void run()
{
String namaThread = Thread.currentThread().getName();
for(int i = 0; i < 5; i++)
{
System.out.println(namaThread + ":" + i);
}
}
}
|
Listing program di atas akan menghasilkan :
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-1:0
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-2:0
Thread-2:1
Thread-2:2
Thread-2:3
Thread-2:4
|
· Dalam thread tidak ada jaminan bahwa thread akan berjalan sesuai dengan urutan method start() dipanggil [1]. Hal ini terjadi karena thread mana yang berjalan dipilih oleh thread scheduler [1].
Listing program xx : UrutanThread.java
|
package thread;
public class UrutanThread
{
public static void main(String[] args)
{
MyJob job = new MyJob();
Thread[] thread = new Thread[1000];
for(int i=0; i<thread.length; i++)
{
thread[i] = new Thread(job);
thread[i].start();
}
}
}
class MyJob implements Runnable
{
public void run()
{
String namaThread = Thread.currentThread().getName();
System.out.println(namaThread);
}
}
|
Beberapa baris hasil listing program di atas :
......
Thread-550
Thread-552
Thread-551
Thread-553
Thread-554
......
|
· Dalam satu buah thread (job / urutan eksekusi), urutan eksekusi pasti berurutan. Tetapi thread pekerja tidak pasti berurutan [3].
Listing program xx :UrutanThread2.java
|
package thread;
public class UrutanThread2
{
public static void main(String[] args)
{
MyJob2 myJob = new MyJob2();
Thread t1 = new Thread(myJob);
Thread t2 = new Thread(myJob);
Thread t3 = new Thread(myJob);
Thread t4 = new Thread(myJob);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class MyJob2 implements Runnable
{
public void run()
{
String namaThread = Thread.currentThread().getName();
for(int i=0; i<100; i++)
{
System.out.println(namaThread + ":" + i);
}
}
}
|
Beberapa baris hasil listing program di atas :
……
Thread-2:83
Thread-1:97
Thread-2:84
Thread-3:77
Thread-2:85
Thread-3:78
Thread-1:98
Thread-2:86
Thread-3:79
……
|
Keterangan : Dalam satu buah thread pasti akan mencetak sesuai dengan urutan eksekusi 1,2,3,...99. Akan tetapi belum tentu thread yang berjalan adalah Thread-1, diikuti dengan Thread-2, dan kemudian Thread-3 (urutan tidak pasti).
|
3. Thread Priorities
· Thread selalu memiliki priority. Priority ini menentukan peluang suatu thread memasuki state running. Semakin tinggin nomer priority thread, semakin besar thread tersebut dipilih oleh thread scheduler untuk masuk ke dalam state running [1].
· Priority ini biasanya direpresentasikan dengan nomer antara 1 sampai dengan 10 (kadang ada JVM yang menggunakan nomer antara 1 sampai dengan 5) [1].
· Dalam kelas java.lang.Thread terdapat beberapa method dan konstanta yang berhubungan dengan thread priorities, yaitu [3]:
1. public static final int MIN_PRIORITY
2. public static final int NORM_PRIORITY
3. public static final int MAX_PRIORITY
4. public final void setPriority(int priority)
5. public final int getPriority()
Contoh [3] :
Listing program xx
|
public class Priority1 {
public static void main(String[] args) {
String name = Thread.currentThread().getName();
int priority = Thread.currentThread().getPriority();
System.out.println(name + " : " + priority);
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
priority = Thread.currentThread().getPriority();
System.out.println(name + " : " + priority);
}
}
|
Listing program di atas akan menghasilkan :
main : 5
main : 10
|
· Default priority dari suatu thread adalah priority yang sama dengan thread pencipta [1].
Contoh [3]:
Listing program xx
|
package thread;
public class Priority2 {
public static void main(String[] args) {
String name = Thread.currentThread().getName();
int priority = Thread.currentThread().getPriority();
System.out.println(name + " : " + priority);
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
priority = Thread.currentThread().getPriority();
System.out.println(name + " : " + priority);
NewThread t = new NewThread();
t.start();
}
}
class NewThread extends Thread {
public void run() {
String name = Thread.currentThread().getName();
int priority = Thread.currentThread().getPriority();
System.out.println(name + " : " + priority);
}
}
|
Listing program di atas akan menghasilkan :
main : 5
main : 10
Thread-0 : 10
|
· JVM tidak akan pernah merubah priority dari suatu thread [1].
4. State dan Transition dari Thread
 |
· Thread dalam java dapat memiliki 5 buah state, yaitu :
1. New
2. Runnable
3. Running
4. Non-runnable (sleeping / waiting / blocked)
5. Dead
· Dari 5 buah state di atas, dapat dipersempit menjadi 3 buah keadaan, yaitu :
1. New (state new)
2. Alive (state runnable, running, non-runnable)
3. Dead (state dead)
3.1 Thread State
3.1.1 State : New
· State new adalah state dari sebuah thread ketika sebuah object dari kelas java.lang.Thread baru dibuat (diinstansiasi), akan tetapi method start() belum dipanggil dari object tersebut.
Listing program xx : StateNew1.java
|
package thread;
public class StateNew1
{
public static void main(String[] args)
{
ThreadKu t1 = new ThreadKu(); //State new
}
}
class ThreadKu implements Runnable
{
public void run()
{
String namaThread = Thread.currentThread().getName();
System.out.println(namaThread + " is running");
}
}
|
· Pada state new ini, sebuah job telah dibuat akan tetapi worker belum bekerja.
3.1.2 State : Runnable
· Thread pertama kali masuk ke state runnable ini ketika method start() dipanggil dari instance kelas java.lang.Thread [1].
Listing program xx : StateNew1.java
|
package thread;
public class StateNew1
{
public static void main(String[] args)
{
ThreadKu t1 = new ThreadKu(); //State new
t1.start(); //Masuk ke state runnable
}
}
class ThreadKu implements Runnable
{
public void run()
{
String namaThread = Thread.currentThread().getName();
System.out.println(namaThread + " is running");
}
}
|
· Selain karena method start(), suatu thread dapat masuk ke state runnable ini dari state sleeping / waiting / blocked [1].
· Ketika suatu thread berada dalam state runnable, maka thread tersebut dapat dipilih sewaktu-waktu oleh thread scheduler menjadi state running [1].
· Dalam satu waktu ada kemungkinan lebih dari satu thread berada dalam state ini. Kumpulan state tersebut dapat dianggap berada dalam sebuah tempat yang bernama runnable pool [3].
3.1.3 State : Running
· State running ini terjadi ketika thread scheduler memilih sebuah thread untuk dijalankan dari runnable pool [1].
· Ketika dalam state ini, maka suatu kode program dari method run() sedang dijalankan [3].
Listing program xx : StateRunning1.java
|
package thread;
public class StateRunning1
{
public static void main(String[] args)
{
ThreadKu t1 = new ThreadKu();
t1.start();
}
}
class ThreadKu extends Thread
{
public void run()
{
String namaThread = Thread.currentThread().getName();
String tulisan = "Bila tulisan ini dicetak, maka " +
"thread " + namaThread + " sedang dalam state " +
"running";
for(int i=0; i<10; i++)
{
System.out.println(tulisan);
}
}
}
|
Beberapa baris hasil program di atas adalah :
.....
Bila tulisan ini dicetak, maka thread Thread-0 sedang dalam state running
Bila tulisan ini dicetak, maka thread Thread-0 sedang dalam state running
Bila tulisan ini dicetak, maka thread Thread-0 sedang dalam state running
Bila tulisan ini dicetak, maka thread Thread-0 sedang dalam state running
.....
|
· Suatu thread dapat keluar dari state ini karena beberapa hal, diantaranya [3]:
1. Masuk ke state sleep karena thread ini memanggil method sleep()
2. Pemanggilan method yield().
3. Pemanggilan method join().
4. Method run() telah selesai dieksekusi
5. Masuk ke state waiting karena method wait() pada sebuah object.
6. Masuk ke state blocked karena mekanisme lock ataupun karena IO block
7. Scheduler memilih thread ini untuk kembali ke state runnable
· Suatu thread dapat masuk ke state ini hanya karena satu hal, yaitu thread tersebut dipilih oleh thread scheduler untuk memasuki state running.
3.1.3.1 yield()
· Method yield() ini akan menyebabkan thread pemanggil method akan masuk dari state running menuju state runnable dan menyebabkan thread lain (dengan priority yang sama dengan thread pemanggil yield) yang ada di dalam runnable pool untuk dijalankan [1].
· Tidak ada jaminan keberhasilan method yield() dalam menjalankan tugasnya [3].
· Contoh :
Program xx
|
package mythread;
public class MyThread03 {
public static void main(String[] args) {
//JOB
BercocokTanam job1 = new BercocokTanam(100, 5);
BercocokTanam job2 = new BercocokTanam(150, 10);
//Worker
Thread pekerja1 = new Thread(job1, "Welly");
Thread pekerja2 = new Thread(job2, "Haunz");
//Mulai bekerja
pekerja1.start();
pekerja2.start();
}
}
class BercocokTanam implements Runnable {
private int jumlah;
private int ganti;
public BercocokTanam(int jumlah, int ganti) {
this.jumlah = jumlah;
this.ganti = ganti;
}
public void run() {
String nama = Thread.currentThread().getName();
for(int i = 0; i < jumlah; i++) {
System.out.println(nama + " => Saya menanam : " + i);
if(i % ganti == 0) {
System.out.println(nama + " Saya ingin orang lain menggantikan saya");
}
}
}
}
|
Program di atas akan menghasilkan :
......
Welly => Saya menanam : 40
Welly Saya ingin orang lain menggantikan saya
Welly => Saya menanam : 41
Welly => Saya menanam : 42
Welly => Saya menanam : 43
Welly => Saya menanam : 44
Welly => Saya menanam : 45
Haunz => Saya menanam : 3
Welly Saya ingin orang lain menggantikan saya
Haunz => Saya menanam : 4
......
|
3.1.4 State : Sleeping
· Suatu thread mungkin tertidur untuk suatu waktu (karena method sleep() yang dipanggil dari dalam method run).
3.1.4.1 sleep()
· Method sleep() adalah method static dari kelas java.lang.Thread [1].
public static native void sleep(long milisecond)
throws java.lang.InterruptedException
· Ketika suatu thread memanggil Thread.sleep(x), maka thread pemanggil tersebut akan langsung masuk ke dalam state sleeping selama x milisecond, dan setelah x milisecond, thread tersebut akan masuk ke state runnable [3].
Contoh [3]:
Listing program xx
|
package thread;
public class Sleep {
public static void main(String[] args) {
ThreadSleep1 ts = new ThreadSleep1();
Thread thread = new Thread(ts);
thread.start();
}
}
class ThreadSleep1 implements java.lang.Runnable {
public void run() {
String nama = Thread.currentThread().getName();
System.out.println(nama + ": aku akan tidur selama 5 detik");
try {
Thread.sleep(5 * 1000);
}
catch(InterruptedException ignore) {
//ignore
}
System.out.println(nama + ": aku bangun dari tidur");
}
}
|
Listing program di atas akan menghasilkan :
Thread-0: aku akan tidur selama 5 detik
Thread-0: aku bangun dari tidur
|
· Yang harus diperhatikan dalam pemanggilan method sleep adalah [3]:
1. Pemanggilan haruslah Thread.sleep(x) bila thread pemanggil adalah implements dari java.lang.Runnable. Pemanggilan dapat berupa sleep(x) bila thread pemanggil adalah extendsdari java.lang.Thread [3].
2. Pemanggilan sleep(x) ataupun Thread.sleep(x) harus berada dalam block try-catch, karena Thread.sleep(x) melemparkan exception InterruptedException [1].
3. Ketika suatu thread memanggil method Thread.sleep(x), maka thread tersebut akan keluar dari state running selama minimal x milisecond. Dikatakan minimal karena thread tersebut berada di state sleeping selama x milisecond ditambah dengan suatu waktu (yang tidak dapat ditentukan) ketika thread tersebut di dalam state runnable [3].
4. Suatu thread tidak akan dapat menyebabkan thread lain masuk ke state sleeping (dengan cara apapun). Suatu thread dapat masuk ke state sleeping hanya karena thread tersebut memang memanggil method Thread.sleep(x).
3.1.5 State : Blocked
· Suatu thread berada dalam state blocked karena beberapa hal, diantaranya [3]:
1. Menunggu resource IO
2. Pemanggilan method join()
3. Locking (object locking dan class locking)
· Suatu thread kembali ke state runnable bila resource telah tersedia (untuk state yang terblock karena menunggu resource IO dan karena locking) [1].
· Untuk exam tidak dibahas state blocked karena menunggu resource IO [1].
· State blocked karena locking dibahas pada subbab 4 (Synchronization) [3]
3.1.5.1 join()
· Dalam kelas java.lang.Thread terdapat method sebagai berikut :
1. public final void join() throws java.lang.InterruptedException
2. public final void join(long milisecond) throws java.lang.InterruptedException
· Method join menyebabkan suatu thread bergabung ke akhir thread lain [1]. Thread yang bergabung adalah thread yang memanggil method join [3].
Contoh [3]:
Listing program xx
|
package thread;
public class Join {
public static void main(String[] args) {
A a = new A();
Thread t = new Thread(a);
t.start();
}
}
class A implements java.lang.Runnable {
public void run() {
String nama = Thread.currentThread().getName();
System.out.println(nama + ": sebelum join");
B b = new B();
Thread t = new Thread(b);
t.start();
try {
t.join();
/*
* statement di atas menyebabkan thread yang
* memanggil t.join akan menunggu sampai
* dengan thread t selesai.
*/
}
catch(InterruptedException ignore) {
//ignore
}
System.out.println(nama + ": setelah join");
}
}
class B implements java.lang.Runnable {
public void run() {
String nama = Thread.currentThread().getName();
for(int i=0; i<5; i++) {
System.out.println(nama + ": " + i);
}
}
}
|
Program di atas akan menghasilkan :
Thread-0: sebelum join
Thread-1: 0
Thread-1: 1
Thread-1: 2
Thread-1: 3
Thread-1: 4
Thread-0: setelah join
|
· Pengertian t.join() adalah : Gabungkan aku (thread pengeksekusi t.join()) ke akhir thread t [1].
· Method join() pada kelas java.lang.Thread memiliki overload method join(long milisecond). Method join(long milisecond) memiliki efek sama seperti method join(), dengan pengecualian bila thread yang dijoin berjalan lebih dari x milisecond, maka thread yang bergabung akan berhenti menunggu dan langsung masuk ke state runnable [3].
Contoh [3]:
Listing program xx
|
package thread;
public class Join2 {
public static void main(String[] args) {
A a = new A();
Thread t = new Thread(a);
t.start();
}
}
class A implements java.lang.Runnable {
public void run() {
String nama = Thread.currentThread().getName();
System.out.println(nama + ": sebelum join");
B b = new B();
Thread t = new Thread(b);
t.start();
try {
t.join(1);
/*
* statement di atas menyebabkan thread yang
* memanggil t.join akan menunggu sampai
* dengan thread t selesai.
*/
}
catch(InterruptedException ignore) {
//ignore
}
System.out.println(nama + ": setelah join");
}
}
class B implements java.lang.Runnable {
public void run() {
String nama = Thread.currentThread().getName();
for(int i=0; i<5000; i++) {
System.out.println(nama + ": " + i);
}
}
}
|
Listing program di atas akan menghasilkan :
Thread-0: sebelum join
Thread-1: 0
Thread-1: 1
………………………
Thread-1: 72
Thread-0: setelah join
Thread-1: 73
Thread-1: 74
………………………
|
3.1.6 State : Waiting
3.1.5 State : Dead
· Suatu thread dinyatakan dalam state dead bila method run() telah selesai dikerjakan [1], atau bila dalam pengerjaan method run() tersebut terjadi exception yang tidak ditangkap [2].
· Suatu thread yang telah memasuki state dead tetap dianggap sebagai object dari kelas java.lang.Thread, akan tetapi bukan lagi dianggap sebagai urutan eksekusi (Thread of execution) [1].
· Ketika suatu thread telah memasuki state dead, maka thread tersebut tidak akan dapat masuk ke state lainnya [1].
· Ketika suatu thread telah memasuki state dead, maka thread tersebut tidak dapat dipanggil dengan method start() lagi (sebab akan menimbulkan runtime exception) [1].
Contoh [3]:
Listing program xx
|
package thread;
public class MyThread04
{
public static void main(String[] args)
{
MySimpleThread t1 = new MySimpleThread();
t1.start();
t1.start();
}
}
class MySimpleThread extends Thread
{
public void run()
{
String namaThread = Thread.currentThread().getName();
System.out.println(namaThread + ": method run()");
}
}
|
Listing program di atas akan menghasilkan :
Thread-0: method run()
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.start(Unknown Source)
at thread.MyThread04.main(MyThread04.java:9)
|
Comments
Post a Comment