MULTITHREADING

Thread (lightweight process raut execution context) adalah sebuah singlesequential

flow control di dalam program. Secara sederhana, thread adalah sebuah sub program yang
berjalan di dalam program. Sebuah thread mempunyai awal dan akhir. Multhithreading
adalah program yang mempunyai beberapa flow of control yang berjalan secara konkuren
atau pararel.
Scheduler JVM mendukung :
a. preemptive multithreading, suatu thread prioritas tinggi bisa menyeruak masuk dan
menginterupsi thread yang sedang beraksi.
b. non-preemptive (cooperative) multithreading, thread yang sedang beraksi tidak
dapat diinterupsi.
Ada dua macam thread dalam Java, yaitu :
1. Daemon thread, merupakan thread yang siklus hidupnya tergantung pada thread
utama. Apabila thread utama berakhir maka otomatis thread-thread daemon juga
berakhir.
2. User thread, apabila thread utama berakhir maka user thread akan terus dijalankan.

Daur hidup thread :

♦ newborn
thread diinstantiasi, sebuah ruangan di telah dialokasikan untuk thread ini dan telah
menyelesaikan tahap inisialisasi. Pada state ini, timerThread belum masuk dalam
skema penjadwalan.
….
Thread coba = new Thread ( );
….
♦ Runnable
Sebuah thread berada dalam skema penjadwalan akan tetapi dia tidak sedang
beraksi.
…..
coba.start()
♦ Running
Pada state ini, thread sedang beraksi. Jatah waktu beraksi ditentukan oleh thread
scheduler. Thread yang berada dalam state ini dapat juga lengser secara sukarela,
dan masuk kembali ke status runnable, sehingga thread lain yang sedang menunngu
giliran memperoleh kesempatan untuk beraksi. Tindakan thread yang lengser secara
sukarela disebut dengan yield-ing.
public void run ( ){
…
Thread.yield();
…. }
♦ Blocked
Pada tahap ini thread sedang tidak beraksi dan diabaikan dalam penjadwalan. Suatu
thread terblok jika :
a. Thread itu tidur untuk jangka waktu tertentu.
Thread.sleep(3000); // tidur selama 3000milisecond = 3 menit.
b. Thread itu di-suspend( )
Thread yang ter-suspend bisa masuk kembali ke ruunable bila ia di resume.

,PBO 1
 ……….
timerThread.suspend( ); // thread memasuki state blok
timerThread.resume( ); // thread memasuki state runnable
…
c. Thread tersebut memanggil method wait( ) dari suatu objek yang sedang ia
kunci. Thread tersebut bisa kembali ke ruunable bila ada thread lain yang
memanggil method notify( ) atau notifyAll( ) dari objek tersebut.
d. Bila thread ini menunggu selesainya aktivitas yang berhubungan dengan
I/O.
e. Bila thread mencoba mengakses critical section dari suatu objek yang
sedang dikunci oleh thread lain. Critical section adalah segmen dalam kode,
bisa berupa method maupun blok dimana beberapa thread yang berbeda
mengakses objek yang sama.
♦ Dead
Suatu thread secara otomatis disebut mati bila method run()-nya sudah diselesaikan.
Suatu thread juga bisa dead bila ia di stop( ).

Untuk mendefinisikan thread ada dua cara, yaitu :

1. Membuat subclass dati Thread
2. Mengimplementasikan Interface Runnable.

1. Thread dengan membuat subclass dari java.lang.Thread :

public class Coba1 extends Thread

{ String nama;
coba1(String nm) { nama = nm ; }
public void run ( )
{
for(int i = 0; i<100; i++) { System.out.print (nama); }
}
public static void main (String args[ ]) {
Thread t = Thread.currentThread(); //mendapatkan thread yg sedang
berjalan
System.out.println(t);
t.setName(“Threadku”); System.out.prinln(t); //merubah nama thread
coba1 t1 = new coba1(“A”);
coba1 t2 = new coba1(“B”);
coba1 t3 = new coba1(“C”);
t1.start(); //mejalankan method run
t2.start();
t3.start(); }}

Out program diatas Program akan memberikan kluaran yang berbeda tiap kali eksekusi.
Misal : Thread[main,5,main]
Thread[Threadku,5,main]
AAAAAAAABBCCCCBCABBCCABBBBCCBC………….AABBBB

2. Thread dengan mengimplementasikan Interface Runnable

Bentuk : Thread objek = new Thread(Objekrunnable,<String name>);
Objek.start();

,PBO 2
 atau
new Thread(Objekrunnable,<String name>).start();

Contoh :
public class Coba2 implements Runnable
{ String nama;
Coba2 (String nm) {
nama=nm;
Thread objek = new Thread(this) ; objek.start(); }
public void run ( )
{
for(int i = 0; i<100;i++) {
System.out.print (nama); }
}
public static void main (String args[ ]) {
Coba2 t1 = new Coba2(“A”);
Coba2 t2 = new Coba2(“B”);
Coba2 t3 = new Coba2(“C”);
}}

Output sama dengan contoh program pertama.

ket :
untuk menjalankan thread, lakukan dengan memanggil method start(). Saat start()
dijalankan maka sebenarnya mehod run() dari class dijalankan.

Jenis thread ada dua,yaitu :

a. Daemon merupakan thread yang siklus hidupnya tergantung pada thread utama (main).
Bila thread induk berakhir, maka thread daemon juga berakhir.
b. User merupakan thread yang memiliki siklus tidak tergantung pada siklus
thread utama. apabila thread utama berakhir maka user thread akan terus dijalankan.

Contoh :

import java.io.*;
public class user extends Thread
{ String nama;
user(String nm) { super(nm); /**menjalankan thread dengan sekali instantiasi*/
nama = nm ; start(); }
public void run ( )
{ while(true) { System.out.print (nama); } }

public static void main (String args[ ]) {

user t1 = new user("A");
user t2 = new user("B");
user t3 = new user("C");
try{ System.in.read();
System.out.println(" Tombol enter ditekan");}
catch(IOException o)
{System.out.println(o);}
System.out.println("selesai"); }}

,PBO 3
 1
Apabila dijalankan maka program ini akan menampilkan A, B, dan C secara
bergantian. Bila kita menekan tombol enter maka akan keluar :
Tombol enter ditekan
selesai
Setelah thread utama yang menjalankan method main berakhir maka thread yang telah
dibuat akan terus berjalan karena merupakn tipe user thread. Untuk menghentikan tekan
tombol Control+C.
Untuk menjadikan suatu thread menjadi daemon thread, gunakan method
setDaemon(true). Misal pada contoh1 pada method Coba1(String nm) menjadi :

Coba1(String nm) { super(nm); nama = nm ; setDaemon(true) ; start(); }

maka ketika menekan enter program berhenti termasuk semua thread-thread yang ada.

Sinkronisasi
Satu atau lebih thread membutuhkan akses yang hampir bersamaan ke suatu
sumber daya terbagi, maka thread-thread tersebut perlu sangat memperhatikan agar hanya
ada satu yang mengakses dalam satu saat. Java menyediakan dukungan tingkat bahasa
yang unik untuk sinkronisasi yang disebut monitor. Monitor adalah suatu objek yang
digunakan sebagai kunci eksklusif untuk kepentingan bersama. Cara untuk memasuki
suatu monitor objek adalah dengan memanggil suatu method yang ditandai dengan kata
kunci synchronize.

Bentuk : synchronize(<object>) { //satemen yang akan disinkronisasikan }

Contoh Synchronized pertama

class hasil{
static void cetak(String str1, String str2) {
try { System.out.print (str1); Thread.sleep(1000);
System.out.println(str2); }
catch(Exception e)
{ System.out.println(e); }
}}

public class Coba2 implements Runnable

{ String nama,angka;
Coba2 (String str1, String str2) { nama=str1; angka=str2 ;
new Thread(this); //membuat objk thread (new born)
objek.start(); }
public void run ( ) {
hasil.cetak(str1,str2) ; }
public static void main (String args[ ]) {
new Coba2("A","1");
new Coba2("B","2");
new Coba2("C","3");
}}
out : ABC1
2

,PBO 4
 3
Ini disebabkan tidak adanya sesuatu yang menhgentikan ketiga thread untuk memanggil
method yang sama pada objek yang sama. Bila kita tambahkan kata kunci synchronized
menjadi :

class hasil {
synchronized static void cetak (String srt1,String str2) {…………. }

Out menjadi :
A1
B2
C3

Contoh Synchronized kedua

class hasil{
void cetak(String str1, String str2){
try{
System.out.print (str1); Thread.sleep(100);
System.out.println(str2); }
catch(Exception e){System.out.println(e); }
}}
public class Coba2 implements Runnable
{ String nama,angka;
hasil cetak1;

Coba2 (String str1, String str2,hasil cetak1)

{ nama=str1; angka=str2 ;this.cetak1=cetak1;
Thread a = new Thread(this,”Thread sinkronisasi”);
System.out.println(a); a.start();}
public void run ( )
{
synchronized (cetak1) {cetak1. cetak(nama,angka); }
}
public static void main (String args[ ]) {
hasil cetak1 = new hasil();
Coba2 t1 = new Coba2("A","1",cetak1);
Coba2 t2 = new Coba2("B","2",cetak1);
Coba2 t3 = new Coba2("C","3",cetak1);
}}

Out : Thread[Thread Sinkronisasi,5,main]

Thread[Thread Sinkronisasi,5,main]
Thread[Thread Sinkronisasi,5,main]
A1
B2
C3

,PBO 5
 Komunikasi Thread
Java memasukkan suatu mekanisme antar-proses yang elegan berupa method wait,
notify, dan notifyAll. Method-method ini diimplementasikan sebagai method-method final
pada objek sehingga semua class memilikinya. Ketiga method tersebut hanya boleh
dipanggil dari dalam method synchronized.
♦ wait : memberitahukan thread yang berlaku untuk menyerahkan monitor dan
beristirahat sampai suatu jalinan lain memasuki monitor.
♦ notify: membangunkan jalinan pertama yang memanggil wait pada objek yang
sama.
♦ notifyAll:membangunkan semua objek yang memanggil wait pada objek yang
sama. Thread dengan prioritas tertinggi yang bangun akan jalan terlebih dahulu.

Method cflass thread :

♦ Thread.currentThread()
menghasilkan objek thread berupa thread yang sedang berjalan.
♦ Thread.yield()
Menyebabkan runtime mengalihkan konteks dari thread yang berlaku ke thread lain
yang tersedia dan dapat dijalankan.
♦ Thread.sleep(int n)
Menyebabkan thread yang berlaku beristirahat selam n milidetik.
Method instans :
♦ start()
Memberitahukan runtime java untuk menciptakan konteks jalinan dan
menjalankannya.
♦ run()
Metod run adalah badan thread yang berjalan.
♦ stop()
Menyebabkan thread segera berhenti.
♦ suspend()
Suspend mengambil thread tertentu dan menyebabkanya berhenti tanpa
menghancurkan thread system yang berjalan sebelumnya.
♦ resume()
Digunakan untuk menghidupkan method yang di-suspend.
♦ setPriority(int p)
mengisiprioritas suatu thread dengan besaran integer. Ada beberapa konstanta
priority, yaitu MIN_PRIORITY, NORM_PRIORITY, dan MAX_PRIORITY,
secara berurutan bernilai 1,5,10.
♦ getPriority()
mengjhasilkan prioritas thread, berupa suatu nilai antara 1 sampai 10.
♦ setName(String name)
Mengulang pemberian nama thread sesuai dengan argument name.

,PBO 6