Page |1

BAB I
PENDAHULUAN

1.1. Latar Belakang

Java adalah bahasa pemrograman banyak thread, yang artinya
beberapa hal bisa dilakukan bersama-sama. Thread adalah unit terkecil dari
eksekusi suatu program. Thread mengeksekusi rangkaian instruksi satu
demi satu. Ketika sistem menjalankan program, komputer akan membuat
thread baru. (Thread dalam konteks ini disebut proses, akan tetapi
perbedaanya tidank penting di sini). Instruksi-instruksi dalam program akan
dieksekusi oleh thread ini secara berantai, satu demi satu dari awal hingga
akhir. Thread disebut "mati" jika program selesai dieksekusi.
Dalam sistem komputer modern, beberapa thread bisa tercipta dalam
satu waktu. Pada satu saat tertentu, hanya ada satu thread yang bisa
dijalankan, karena CPU hanya bisa melakukan satu hal dalam satu waktu.
(Pada komputer dengan multiprosesor, multicore, dan hyper-threading,
masing-masing prosesor atau core melakukan thread yang berbeda-beda).
Akan tetapi sebenarnya komputer membagi waktu menjadi bagian-bagian
kecil sehingga seolah-olah seluruh thread dijalankan secara bersama-sama.
Pembagian waktu berarti CPU mengeksekusi suatu thread dalam kurun
waktu tertentu, setelah itu beralih mengeksekusi thread yang lain, kemudian
thread lain, dan seterusnya dan kemudian kembali ke thread pertama --
kira-kira 100 kali per detik. Di mata user, semua thread berjalan pada saat
yang sama.
Java bisa membuat satu atau lebih thread yang bisa dijalankan secara
paralel. Hal ini adalah bagian mendasar, yang dibuat di dalam core bahasa,
bukan merupakan tambahan (add-on) seperti bahasa pemrograman lain.
Tetap saja pemrogaman dengan banyak thread adalah sesuatu yang tidak
mudah.
 Page |2

Penggunaan thread yang banyak digunakan untuk membuat GUI

(Graphical User Interface) yang responsif. Pada dasarnya suatu program
harus dapat terus bejalan dan pada saat yang sama tetap bisa menerima input
dari user, menanggapi klik mouse, dan sebagainya.
Thread juga digunakan untuk mempercepat suatu proses, misalnya
kita ingin membuat program yang menunggu suatu input I/O dari network,
dan pada saat yang sama mengolahnya sehingga proses pengolahan berjalan
serentak. Jika program harus menunggu seluruh input datang baru kemudian
melakukan pengolahan, tentunya akan memakan waktu yang lebih lama,
terutama apabila aliran network lambat atau pengolahannya memakan
waktu lama.
 Page |3

BAB II
PEMBAHASAN

2.1. Pengertian Thread

Thread adalah sebuah alur kontrol dari sebuah proses. Kontrol single
thread hanya memungkinkan proses untuk menjalankan satu tugas pada satu
waktu. Banyak sistem operasi modern telah memiliki konsep yang
dikembangkan agar memungkinkan sebuah proses untuk memiliki eksekusi
multi-threads, agar dapat secara terus menerus mengetik dan menjalankan
pemeriksaan ejaan didalam proses yang sama, maka sistem operasi tersebut
memungkinkan proses untuk menjalankan lebih dari satu tugas pada satu
waktu.
Suatu proses yang multithreaded mengandung beberapa perbedaan alur
kontrol dengan ruang alamat yang sama. Keuntungan dari multithreaded
meliputi peningkatan respon dari user, pembagian sumber daya proses,
ekonomis, dan kemampuan untuk mengambil keuntungan dari arsitektur
multiprosesor.
Thread merupakan unit dasar dari useran CPU, yang terdiri dari
Thread_ID, program counter , register set, dan stack. Sebuah thread berbagi
code section, data section, dan sumber daya sistem operasi dengan thread
lain yang dimiliki oleh proses yang sama. Thread juga sering disebut
lightweight process.

2.2. Jenis-Jenis Proses Thread

Pada proses thread terdapat dua jenis thread, yaitu:
1. Single Thread Process
Sebuah proses tradisional atau heavyweight process mempunyai
single thread yang berfungsi sebagai pengendali. Dapat diartikan sebagai
proses yang bekerja secara berurutan sesuai dengan urutan masing-masing

3
 Page |4

thread (terstruktur) dan hanya mengerjakan satu tugas dalam satu waktu.
Di bawah ini merupakan gambar single thread.

Gambar 2.1. Single Thread

Contoh program dari single thread adalah sebagai berikut:

//program ke sembilanbelas
//single thread

public class racesingle{

public static void main(String args[]){
raceTest horse1 = new raceTest();
raceTest horse2 = new raceTest();
raceTest horse3 = new raceTest();
System.out.println("\nRace Starting ....\n");

System.out.println("Race started!\n\n");
horse1.run("horse1");
horse2.run("horse2");
horse3.run("horse3");
}
}
class raceTest{
private int pause;
private int stage=0;
public void run(String name){
 Page |5

try{
System.out.println(name + " started!");
do{
System.out.println(
" - stage: " + (stage+1)
);
pause = (int) (Math.random() * 1000);
stage++;
} while (stage<5);
}
catch(Exception exception){
System.out.println(exception.toString());
}
System.out.println(name + " finished!");
}
}

Program ke-sembilanbelas menggunakan single thread, dimana

setelah horse1 telah selesai di proses maka horse2 diproses, kemudian
horse3 diproses.
Hasil program:
Race Starting ....
Race started!
horse1 started!
- stage: 1
- stage: 2
- stage: 3
- stage: 4
- stage: 5
horse1 finished!
horse2 started!
- stage: 1
- stage: 2
- stage: 3
- stage: 4
- stage: 5
horse2 finished!
horse3 started!
- stage: 1
- stage: 2
 Page |6

- stage: 3
- stage: 4
- stage: 5
horse3 finished!
Finished executing

2. Multithread Process
Merupakan satu atau beberapa thread yang dijalankan secara
bersamaan (multiproses), dimana masing-masing thread tersebut
dijalankan pada jalur masing-masing. Setiap thread pada multithread
menjalankan kode atau script program secara berurutan. Multithread
dapat diartikan juga sebagai suatu proses dengan thread banyak dapat
mengerjakan lebih dari satu tugas pada satu satuan waktu.
Multithread sering pula disebut dengan multiproses atau
multitasking pada sistem operasi. Gambar multithread ditunjukkan pada
gambar 2.2.

Gambar 2.2. Multitread

 Page |7

Banyak perangkat lunak yang berjalan pada PC modern dirancang

secara multithreading. Sebuah aplikasi biasanya diimplementasi sebagai
proses yang terpisah dengan beberapa thread yang berfungsi sebagai
pengendali. Contohnya sebuah web browser mempunyai thread untuk
menampilkan gambar atau tulisan sedangkan thread yang lain berfungsi
sebagai penerima data dari network.
Kadang kala ada situasi dimana sebuah aplikasi diperlukan untuk
menjalankan beberapa tugas yang serupa. Sebagai contohnya sebuah web
server dapat mempunyai ratusan klien yang mengaksesnya secara concurrent.
Kalau web server berjalan sebagai proses yang hanya mempunyai single
thread maka ia hanya dapat melayani satu klien pada pada satu satuan waktu.
Bila ada klien lain yang ingin mengajukan permintaan maka ia
harus menunggu sampai klien sebelumnya selesai dilayani. Solusinya
adalah dengan membuat web server menjadi multithreading. Dengan ini
maka sebuah web server akan membuat thread yang akan mendengar
permintaan klien, ketika permintaan lain diajukan maka web server akan
menciptakan thread lain yang akan melayani permintaan tersebut.
Contoh program dari mutithread dari pengembangan program single
thread (program ke-sembilanbelas)
//program keduapuluh
//multithread
public class race{
public static void main(String args[]){
raceThread horse1 = new raceThread("horse1");
raceThread horse2 = new raceThread("horse2");
raceThread horse3 = new raceThread("horse3");
System.out.println("\nRace Starting ....\n");

// Mulai Thread
horse1.start();
horse2.start();
horse3.start();
System.out.println("Race started!\n\n");
}
}
 Page |8

class raceThread extends Thread{

private int pause;
private int stage=0;
public raceThread(String name){
super(name);
}
public void run(){
try{
do {
System.out.println(
this.getName()
+ " - stage: " + (stage+1)
);
pause = (int) (Math.random() * 1000);
Thread.sleep(pause);
stage++;
} while (stage<5);
}
catch(InterruptedException exception){
System.out.println(exception.toString());
}
System.out.println(getName() + " finished!");
}
}

Program di atas menggunakan multithread yang berarti modul

horse1 diproses, kemudian tanpa harus menunggu horse1 selesai diproses,
maka horse2 dapat diproses, begitu pula horse3, sudah dapat diproses
tanpa harus menunggu horse1 dan horse2 selesai.
Hasil program :
Race Starting ....
horse1 - stage: 1
horse2 - stage: 1
Race started!
horse3 - stage: 1
horse1 - stage: 2
horse1 - stage: 3
horse3 - stage: 2
horse2 - stage: 2
horse3 - stage: 3
 Page |9

horse1 - stage: 4
horse2 - stage: 3
horse1 - stage: 5
horse3 - stage: 4
horse3 - stage: 5
horse1 finished!
horse3 finished!
horse2 - stage: 4
horse2 - stage: 5
horse2 finished!

2.3. Keuntungan Thread

Terdapat empat keuntungan utama dari program yang multithreading,
yaitu sebagai berikut:
1. Responsiveness
Membuat aplikasi yang interaktif menjadi multithreading dapat
membuat sebuah program terus berjalan meski pun sebagian dari
program tersebut diblok atau melakukan operasi yang panjang, karena
itu dapat meningkatkan respons kepada user. Sebagai contohnya dalam
web browser yang multithreading, sebuah thread dapat melayani
permintaan user sementara thread lain berusaha menampilkan image.
2. Resource sharing
Thread berbagi memori dan sumber daya dengan thread lain yang
dimiliki oleh proses yang sama. Keuntungan dari berbagi kode adalah
mengizinkan sebuah aplikasi untuk mempunyai beberapa thread yang
berbeda dalam lokasi memori yang sama.
3. Economy
Dalam pembuatan sebuah proses banyak dibutuhkan pengalokasian
memori dan sumber daya. Alternatifnya adalah dengan useran thread,
karena thread berbagi memori dan sumber daya proses yang memilikinya
maka akan lebih ekonomis untuk membuat dan context switch
thread. Akan sulit untuk mengukur perbedaan waktu antara proses
dan thread dalam hal pembuatan dan pengaturan, tetapi secara umum
pembuatan dan pengaturan proses lebih lama dibandingkan thread. Pada
 P a g e | 10

Solaris, pembuatan proses lebih lama 30 kali dibandingkan pembuatan

thread, dan context switch proses 5 kali lebih lama dibandingkan context
switch thread.
4. Utilization of multiprocessor architectures
Keuntungan dari multithreading dapat sangat meningkat pada arsitektur
multiprocessor, dimana setiap thread dapat berjalan secara pararel di atas
processor yang berbeda. Pada arsitektur processor tunggal, CPU
menjalankan setiap thread secara bergantian tetapi hal ini berlangsung
sangat cepat sehingga menciptakan ilusi pararel, tetapi pada
kenyataannya hanya satu thread yang dijalankan CPU pada satu-satuan
waktu (satu-satuan waktu pada CPU biasa disebut time slice atau
quantum).
2.4. Model Multithread
a. Berdasarkan Thread Support
Sistem operasi telah mendukung proses multithreading. Setiap
sistem operasi memiliki konsep tersendiri dalam
pengimplementasiannya. Sistem operasi dapat mendukung thread pada
tingkatan kernel maupun tingkatan user. Ada dua macam model support
multithread, yaitu:
1) Thread User (User Thread)
Thread yang didukung oleh kernel dimana pengaturannya dilakukan
oleh pustaka thread pada tingkatan user. Karena pustaka yang
menyediakan fasilitas untuk pembuatan dan penjadwalan thread,
thread user cepat dibuat dan dikendalikan.
2) Thread Kernel
Thread yang didukung langsung oleh kernel (sistem operasi).
Pembuatan, penjadwalan dan manajemen thread dilakukan oleh
kernel pada kernel space. Karena dilakukan oleh sistem operasi,
proses pembuatannya akan lebih lambat jika dibandingkan dengan
user thread.
b. Berdasarkan Pemetaan Thread
 P a g e | 11

Model multithreading berdasarkan dengan pemetaan dibedakan

menjadi tiga bagian, yaitu:
1) Many to One
Model ini memetakan beberapa thread tingkatan user ke sebuah
thread tingkatan kernel. Pengaturan thread dilakukan dalam
ruang user sehingga efisien. Hanya satu thread user yang
dapat mengakses thread kernel pada satu saat. Jadi Multiple thread
tidak dapat berjalan secara paralel pada multiprosesor. Contoh dari
many to one adalah Solaris Green Threads dan GNU Portable
Threads. Model Many to One ditunjukkan pada gambar 2.3.

Gambar 2.3. Many to One

2) One to One
Model ini memetakan setiap thread tingkatan user ke setiap thread.
One to One menyediakan lebih banyak concurrency dibandingkan
model Many to One. Keuntungannya sama dengan keuntungan
thread kernel. Kelemahan model ini ialah setiap pembuatan thread
user memerlukan tambahan thread kernel. Karena itu, jika
mengimplementasikan sistem ini maka akan menurunkan kinerja
dari sebuah aplikasi sehingga biasanya jumlah thread dibatasi dalam
 P a g e | 12

sistem. Adapun contoh dari one to one, yaitu Windows NT/XP/2000,

Linux, Solaris 9. Gambar 2.4. menunjukkan model One to One.

Gambar 2.4. One to One

3) Many to Many
Model ini memultipleks banyak thread tingkatan user ke thread
kernel yang jumlahnya sedikit atau sama dengan tingkatan user.
Model ini mengizinkan developer membuat thread sebanyak yang
developer inginkan tetapi concurrency tidak dapat diperoleh karena
hanya satu thread yang dapat dijadwalkan oleh kernel pada suatu
waktu. Keuntungan dari sistem ini ialah kernel thread yang
bersangkutan dapat berjalan secara paralel pada multiprosessor.
Model Many to Many ditunjukkan pada gambar dibawah ini.
 P a g e | 13

Gambar 2.5. Many to Many

2.5. Status Thread

Suatu thread dapat berada dalam salah satu status seperti berikut ini:
1. New
Thread yang berada pada status ini merupakan objek dari kelas Thread
yang baru dibuat, yaitu saat instansiasi objek dengan statement new. Pada
saat thread berada pada status new, belum ada sumber daya yang
dialokasikan, sehingga thread belum bisa menjalankan perintah apapun.
 Menjalankan thread
Method start() dari kelas Thread harus dipanggil, agar thread bisa
menjalankan tugasnya. Ada dua hal yang terjadi pada saat
pemanggilan method start(), yaitu alokasi memori untuk dibuat
dan pemanggilan method run().
2. Runnable
Pada saat method run() dipanggil, maka status thread berubah menjadi
runnable, artinya thread tersebut sudah memenuhi syarat untuk
dijalankan oleh Java Virtual Machine (JVM). Thread yang sedang
berjalan juga dikategorikan dalam status runnable.
 Blocking statement dan interupsi I/O
 P a g e | 14

Yaitu kondisi yang menghalangi pengeksekusian thread. Ada

beberapa jenis blocking statement, seperti pemanggilan method
sleep(), suatu method yang menerima argumen bertipe integer
dalam bentuk milisekon. Argumen tersebut menunjukkan berapa lama
thread akan “tidur”. Selain sleep() dulunya dikenal method
suspend(), tetapi sudah disarankan untuk tidak diguankan lagi
karena mengakibatkan terjadinya deadlock. Disamping adanya
blocking statement, adanya interupsi I/O juga dapat menyebabkan
thread menjadi blocked.
3. Blocked
Status blocking menunjukkan bahwa sebuah thread terhalang untuk
menjalankan tugasnya, sehingga dapat dikatakan thread tersebut terhenti
untuk sementara. Thread akan menjadi runnable kembali jika interval
method sleep()-nya telah berakhir, atau pemanggilan method
resume() untuk mengakhiri method suspend() atau karena I/O
sudah tersedia lagi.
 Keluar dari method run()
Hal ini bisa terjadi karena thread tersebut memang telah
menyelesaikan pekerjaannya di method run(), maupun karena
adanya pembatalan thread.
4. Dead
Setelah keluar dari method run(), thread akan berada dalam status dead
dan menjadi tidak aktif lagi. Status jelas dari thread tidak dapat
diketahui, tetapi method isAlive() mengembalikan nilai boolean untuk
mengetahui apakah thread tersebut dead atau tidak.
Gambar 2.6. merupakan ringkasan dari status thread.
 P a g e | 15

Gambar 2.6. Status Thread

2.6. Class Thread

Ada tiga macam class Thread, yaitu:
a. Constructor
 Thread()
Membuat sebuah object Thread yang baru.
 Thread(String name)
Membuat sebuah object Thread dengan memberikan penamaan yang
spesifik.
 Thread(Runnable target)
Membuat sebuah object Thread yang baru berdasar pada object
Runnable. Target menyatakan sebuah object diaman method run()
dipanggil
 Thread(Runnable target, String name)
Membuat sebuauh object Thread yang baru dengan nama yang
spesifik dan berdasarkan pada object Runnable.
 P a g e | 16

b. Contants
 public final static int MIN_PRIORITY
Nilai prioritas minimum, 0
 public final static int NORM_PRIORITY
Nilai default prioritas, 5
 public final static int MAX_PRIORITY
Nilai prioritas maksimum, 10

c. Method
 public static Thread currentThread()
Mengembalikan sebuah reference kepada thread yang sedang
berjalan.
 public final String getName()
Mengembalikan nama thread.
 public final void setName(String name)
Mengulang pemberian nama thread sesuai dengan argument name.
Hal ini menyebabkan SecurityException.
 public final int getPriority()
Mengembalikan nilai prioritas yang telah diberikan kepada thread
tersebut.
 public final boolean isAlive()
Menunjukkan bahwa thread tersebut sedang berjalan atau tidak.
 public final void sleep (long milis)
Menunda thread dalam jangka waktu milis. Hal ini dapat
menyebabkan InterruptedException.
 Public void run()
Eksekusi thread dimulai dari method ini.
 Public void start()
Menyebabkan eksekusi dari thread berlangsung dengan cara
memanggil method run().
 P a g e | 17

2.7. Prioritas Thread

Untuk menentukan thread mana yang akan menerima control dari
CPU dan akan dieksekusi pertama kali, setiap thread akan diberikan sebuah
prioritas. Sebuah prioritas adalah sebuah nilai integer dari angka 1
sampai dengan 10, dimana semakin tinggi prioritas dari sebuah thread,
berarti semakin besar kesempatan dari thread tersebut untuk dieksekusi
terlebih dahulu.
Sebagai contoh, asumsikan bahwa ada dua buah thread yang berjalan
bersama-sama. Thread pertama akan diberikan prioritas nomor 5,
sedangkan thread yang kedua memiliki prioritas 10. Anggap bahwa thread
pertama telah berjalan pada saat thread kedua dijalankan. Thread kedua akan
menerima control dari CPU dan akan dieksekusi pada saat thread kedua
tersebut memiliki prioritas yang lebih tinggi dibandingkan thread yang pada
saat itu tengah berjalan.
Salah satu contoh dari skenario ini adalah context switch. Sebuah
context switch terjadi apabila sebagian dari thread telah dikontrol oleh CPU
dari thread yang lain. Ada beberapa skenario mengenai bagaimana cara kerja
dari context switch. Salah satu skenario adalah sebuah thread yang sedang
berjalan memberikan kesempatan kepada CPU untuk mengontrol thread
lain sehingga ia dapat berjalan. Dalam kasus ini, prioritas tertinggi dari
thread adalah thread yang siap untuk menerima kontrol dari CPU. Cara yang
lain dari context switch adalah pada saat sebuah thread yang sedang
berjalan diambil alih oleh thread yang memiliki prioritas tertinggi seperti
yang telah dicontohkan sebelumnya.
Hal ini juga mungkin dilakukan apabila lebih dari satu CPU tersedia,
sehingga lebih dari satu prioritas thread yang siap untuk dijalankan. Untuk
menentukan diantara dua thread yang memiliki prioritas sama untuk
menerima kontrol dari CPU, sangat bergantung kepada sistem operasi
yang digunakan. Windows 95/98/NT menggunakan time-slicing dan round-
robin untuk menangani kasus ini. Setiap thread dengan prioritas yang sama
 P a g e | 18

akan diberikan sebuah jangka waktu tertentu untuk dieksekusi sebelum CPU
mengontrol thread lain yang memiliki prioritas yang sama.
Sedangkan Solaris, ia akan membiarkan sebuah thread untuk
dieksekusi sampai thread tersebut menyelesaikan tugasnya atau sampai
secara suka rela membiarkan CPU untuk mengontrol thread yang lain.
Contoh program prioritas dengan menggunakan variable system
MIN_PRIORITY = 1; NORM_PRIORITY = 5; MAX_PRIORITY = 10,
sebagai berikut:
//program ke duapuluhsatu
//programpriority
class A extends Thread{
public void run(){
System.out.println("Thread A started" );
for(int i=1;i<=4;i++){
System.out.println("\t From ThreadA: i= "+i);
}
System.out.println("Exit from A");
}
}

class B extends Thread{

public void run(){
System.out.println("Thread B started");
for(int j=1;j<=4;j++){
System.out.println("\t From ThreadB: j= "+j);
}
System.out.println("Exit from B");
}
}

class C extends Thread{

public void run(){
System.out.println("Thread C started");
for(int k=1;k<=4;k++){
System.out.println("\t From ThreadC: k= "+k);
}
System.out.println("Exit from C");
}
}
 P a g e | 19

class ThreadPriority{
public static void main(String args[]){
A threadA=new A();
B threadB=new B();
C threadC=new C();

threadA.setPriority(Thread.NORM_PRIORITY);
threadB.setPriority(Thread.MIN_PRIORITY);
threadC.setPriority(Thread.MAX_PRIORITY);

threadA.start();
threadB.start();
threadC.start();
System.out.println("End of main thread");
}
}

2.8. Pembuatan Thread

Sebuah thread dapat diciptakan dengan cara menurunkan (extend) class
Thread atau dengan mengimplementasikan sebuah interface Runnable.
a. Extend class Thread
Kelas Thread secara implisit juga meng-implements Runnable. Oleh
karena itu, setiap kelas yang diturunkan dari kelas Thread juga harus
mendefinisikan method run().
Contoh Extend class Thread
 Multithread diimplementasikan sebagai objek dimana objek tersebut
mempunyai Method run()

class MyThread extends Thread{

public void run()
{
// thread body of execution
}
}

 Membuat thread:
MyThread thr1 = new MyThread();
 P a g e | 20

 Menjalankan thread:
thr1.start();

 Atau Membuat Thread Kemudian Dijalankan

new MyThread().start();

b. Implementasi interface Runnable

Cara lain untuk membuat sendiri sebuah thread adalah dengan
mengimplementasikan interface Runnable. Hanya satu method yang
dibutuhkan oleh interface Runnable yaitu method run().
Contoh Implmentasi interface Runnable
 Struktur
class MyThread implements Runnable{
.....
public void run(){
// thread body of execution
}
}

 Membuat Objek
MyThread myObject = new MyThread();

 Membuat Thread Object:

thread thr1 = new Thread( myObject );

 Cara menjalankan
thr1.start();

Dari dua cara untuk menciptakan thread seperti diatas, memilih salah
satu dari kedua cara tersebut bukan sebuah permasalahan. Implement sebuah
interface Runnable menyebabkan lebih banyak pekerjaan yang harus
dilakukan karena kita harus mendeklarasikan sebuah object Thread dan
memanggil method Thread dari object tersebut.
Sedangkan menurunkan (extend) sebuah class Thread, bagaimanapun
menyebabkan class tersebut tidak dapat menjadi turunan dari class yang
lainnya karena Java tidak memperbolehkan adanya multiple inheritance.
.
 P a g e | 21

2.9. Pustaka Thread (Library Thread)

Pustaka thread atau yang lebih familiar dikenal dengan thread
library bertugas untuk menyediakan API untuk programmer dalam
menciptakan dan mengelola thread. Ada dua cara dalam
mengimplementasikan pustaka thread, yaitu:
a. Menyediakan API dalam level pengguna tanpa dukungan dari kernel
sehingga pemanggilan fungsi tidak melalui system call. Jadi, jika
memanggil fungsi yang sudah ada di pustaka, maka akan menghasilkan
pemanggilan fungsi call yang sifatnya lokal dan bukan system call.
b. Menyediakan API di level kernel yang didukung secara langsung oleh
sistem operasi. Pemanggilan fungsi call akan melibatkan system call ke
kernel.
Ada tiga pustaka thread yang sering digunakan saat ini, yaitu: POSIX
Pthreads, Java, dan Win32. Implementasi POSIX standard dapat dengan cara
user level dan kernel level, sedangkan Win32 adalah kernel level. Java API
thread dapat diimplementasikan oleh Pthreads atau Win32.

2.10. Pembatalan Thread (Thread Cancellation)

Thread Cancellation ialah pembatalan thread sebelum tugasnya
selesai. Umpamanya, jika dalam program Java hendak mematikan
Java Virtual Machine (JVM). Sebelum JVM dimatikan, maka seluruh
thread yang berjalan harus dibatalkan terlebih dahulu. Contoh lain adalah di
masalah search. Apabila sebuah thread mencari sesuatu dalam database dan
menemukan serta mengembalikan hasilnya, thread sisanya akan dibatalkan.
Thread yang akan diberhentikan biasa disebut target thread.
Pemberhentian target thread dapat dilakukan dengan 2 cara, yaitu:
a. Asynchronous cancellation.
Suatu thread seketika itu juga membatalkan target thread.
b. Deferred cancellation.
 P a g e | 22

Suatu thread secara periodik memeriksa apakah thread harus batal, cara
ini memperbolehkan target thread untuk membatalkan dirinya secara
terurut.
Hal yang sulit dari pembatalan thread ini adalah ketika terjadi situasi
dimana sumber daya sudah dialokasikan untuk thread yang akan dibatalkan.
Selain itu kesulitan lain adalah ketika thread yang dibatalkan sedang meng-
update data yang ia bagi dengan thread lain. Hal ini akan menjadi masalah
yang sulit apabila digunakan asynchronous cancellation. Sistem operasi akan
mengambil kembali sumber daya dari thread yang dibatalkan tetapi
seringkali sistem operasi tidak mengambil kembali semua sumber daya dari
thread yang dibatalkan.
Alternatifnya adalah dengan menggunakan deffered cancellation. Cara
kerja dari deffered cancellation adalah dengan menggunakan satu thread yang
berfungsi sebagai pengindikasi bahwa target thread akan dibatalkan. Tetapi
pembatalan hanya akan terjadi jika target thread memeriksa apakah thread
harus batal atau tidak. Hal ini memperbolehkan thread untuk memeriksa
apakah thread harus batal pada waktu dimana thread dapat dibatalkan secara
aman yang aman. Pthread merujuk sebagai cancellation points.
Pada umumnya sistem operasi memperbolehkan proses atau thread
untuk dibatalkan secara asynchronous. Tetapi Pthread API menyediakan
deferred cancellation. Hal ini berarti sistem operasi yang
mengimplementasikan Pthread API akan mengizinkan deferred cancellation.

2.11. Penjadwalan Thread

Thread baru dapat dijalankan dengan berbagai macam penjadwalan
pada saat baru dibuat. Kebijakan penjadwalan yang menentukan setiap
proses, di mana proses tersebut akan ditaruh dalam daftar proses sesuai
proritasnya dan bagaimana thread bergerak dalam daftar proses tersebut.
Untuk menjadwalkan thread, sistem dengan model mulithreading many
to many atau many to one menggunakan:
a. Process Contention Scope (PCS).
 P a g e | 23

Pustaka thread menjadwalkan thread pengguna untuk berjalan pada

LWP (lightweight process) yang tersedia.
b. System Contention Scope (SCS).
SCS berfungsi untuk memilih satu dari banyak thread, kemudian
menjadwalkannya ke satu thread tertentu (CPU/Kernel).

2.12. Sinkronisasi
Thread yang berjalan bersama-sama tetapi tidak bergantung satu
dengan yang lainnya. Thread tersebut adalah thread yang berjalan sendiri
tanpa memperhatikan status dan aktifitas dari thread lain yang sedang
berjalan. Pada hal tersebut, setiap thread tidak membutuhkan resource atau
method dari luar sehingga tidak membutuhkan komunikasi dengan thread
lain.
Didalam situasi-situasi tertentu, sebuah thread yang berjalan
bersama-sama kadang membutuhkan resource atau method dari luar. Oleh
karena itu, thread tersebut perlu untuk berkomunikasi satu dengan yang lain
sehingga dapat mengetahui status dan aktifitas mereka.
Contoh program yang tidak disinkronisasi, yaitu sebuah kode sederhana
yang mencetak sebuah string dengan urutan tertentu.
class TwoStrings {
static void print(String str1, String str2) {
System.out.print(str1);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
System.out.println(str2);
}
}

class PrintStringsThread implements Runnable {

Thread thread;
String str1, str2;
PrintStringsThread(String str1, String str2) {
this.str1 = str1;
 P a g e | 24

this.str2 = str2;
thread = new Thread(this);
thread.start();
}
public void run() {
TwoStrings.print(str1, str2);
}
}
class TestThread {
public static void main(String args[]) {
new PrintStringsThread("Hello ", "there.");
new PrintStringsThread("How are ", "you?");
new PrintStringsThread("Thank you ", "very much!");
}
}

Program tersebut diharapkan dapat mencetak dua argument

object Runnable secara berurutan. Permasalahannya adalah, pendeklarasian
method sleep() akan menyebabkan thread yang lain akan dieksekusi
walaupun thread yang pertama belum selesai dijalankan pada saat
eksekusi method print() dari class TwoStrings. Hasil keluaran contoh
program di atas adalah .
Hello How are Thank you there.
you?
very much!

Pada saat berjalan, ketiga thread telah mencetak argument string

pertama mereka sebelum argument kedua dicetak. Sehingga hasilnya adalah
sebuah keluaran yang tidak jelas.
Contoh program diatas, tidak menunjukkan permasalahan yang serius.
Akan tetapi pada aplikasi yang lain hal ini dapat menimbulkan exception atau
permasalahan-permasalahan tertentu.
Berikut ini adalah contoh program yang telah disinkronisasi dari sebuah
objek yang bernama account digunakan oleh beberapa objek, yaitu
MyThread, YourThread, dan HerThread, terlihat pada gambar 2.7.
 P a g e | 25

Gambar 2.7. Shared Object

Didalam objek account tersebut ada nilai yang diubah oleh ketiga
objek yang mengakses objek account. MyThread menambah nilai 1
sebanyak 10 kali dengan pemanggilan objek sebanyak 5 kali pada variabel
balance di dalam objek account.
YourThread mengurangi nilai 1 sebanyak 10 kali pada variable balance
didalam objek account dengan pemanggilan objek sebanyak 5 kali. Dan
HerThread hanya menampilkan nilai variable balance sebanyak 10 kali
didalam objek.
Dengan kata lain balance = 0 + (1 X 10 X 5) – (1 X 10 X 5), hasilnya
adalah 0. Apabila objek tersebut tidak menggunakan synchronized, maka
akan terjadi inconsistent state sehingga nilai tersebut belum tentu
menghasilkan nilai 0.
//program ke duapuluh dua
class InternetBankingSystem {
public static void main(String [] args ) {
Account accountObject = new Account ();
Thread t1 = new Thread(new MyThread(accountObject));
Thread t2 = new Thread(
new YourThread(accountObject)
);
Thread t3 = new Thread(new HerThread(accountObject));
t1.start();
t2.start();
 P a g e | 26

t3.start();
}
}
class MyThread implements Runnable {
Account account;
private int pause;
private int i = 0;
public MyThread (Account s) { account = s;}
public void run() {
try {
do {
account.deposit();
pause = (int) (Math.random() * 10);
Thread.sleep(pause);
i++;
} while (i<5);
}catch(InterruptedException exception){
System.out.println(exception.toString());
}
}
}
class YourThread implements Runnable {
Account account;
private int pause;
private int i = 0;
public YourThread (Account s) { account = s;}
public void run() {
try {
do {
account.withdraw();
pause = (int) (Math.random() * 10);
Thread.sleep(pause);
i++;
} while (i<5);
}catch(InterruptedException exception){
System.out.println(exception.toString());
}
}
}
class HerThread implements Runnable {
Account account;
private int pause;
 P a g e | 27

private int i = 0;
public HerThread (Account s) { account = s; }
public void run() {
try {
do {
account.enquire();
pause = (int) (Math.random() * 10);
Thread.sleep(pause);
i++;
} while(i<5);

}catch(InterruptedException exception){
System.out.println(exception.toString());
}
}
}

//shared object
class Account {
int balance = 0;
int i=0;
public void deposit( ) {
i=0;
do {
balance += 1;
i++;
System.out.println(balance + " deposit " + i);
}while (i<10);
}

public void withdraw( ) {

i=0;
do {
balance -= 1;
i++;
System.out.println(balance + " withdraw " + i );
}while (i<10);
}

public void enquire( ) {

i=0;
do {
 P a g e | 28

i++;
System.out.println(balance + " Enquire " + i);
}while (i<10);
}
}

Hasil program di atas adalah

1 deposit 1
2 deposit 2
3 deposit 3
4 deposit 4
5 deposit 5
…
7 Enquire 6
7 Enquire 7
7 Enquire 8
7 Enquire 9
7 Enquire 10
Finished executing

Kemudian program ke-duapuluhdua diubah dengan tambahan

synchronized pada semua method di objek class account.

class Account {
int balance = 0;
int i=0;
public synchronized void deposit( ) {
i=0;
do {
balance += 1;
i++;
System.out.println(balance + " deposit " + i);
}while (i<10);

}
public synchronized void withdraw( ) {
i=0;
do {
balance -= 1;
i++;
 P a g e | 29

System.out.println(balance + " withdraw " + i );

}while (i<10);
}
public synchronized void enquire( ) {
i=0;
do {
i++;
System.out.println(balance + " Enquire " + i);
}while (i<10);
}
}

Setelah program dijalankan maka lihat hasilnya, adalah:

1 deposit 1
2 deposit 2
3 deposit 3
4 deposit 4
5 deposit 5
…
-5 deposit 5
-4 deposit 6
-3 deposit 7
-2 deposit 8
-1 deposit 9
0 deposit 10
0 Enquire 1
0 Enquire 2
0 Enquire 3
0 Enquire 4
0 Enquire 5
0 Enquire 6
0 Enquire 7
0 Enquire 8
0 Enquire 9
0 Enquire 10
Finished executing
 P a g e | 30

BAB III
PENUTUP

3.1. Kesimpulan

Thread adalah sebuah alur kontrol dari sebuah proses. Thread terbagi menjadi dua
jenis yaitu Single Thread dan Multithread. Dilihat dari kegunaannya multithread
adalah thread yang paling banyak dipakai akhir-akhir ini. Suatu proses yang
multithreaded mengandung beberapa perbedaan alur kontrol dengan ruang alamat
yang sama. Keuntungan dari multithreaded meliputi peningkatan respon dari user,
pembagian sumber daya proses, ekonomis, dan kemampuan untuk mengambil
keuntungan dari arsitektur multiprosesor. User level thread adalah thread yang
tampak oleh programmer dan tidak diketahui oleh kernel. User level thread secara
tipikal dikelola oleh sebuah library thread di ruang user. Kernel level thread
didukung dan dikelola oleh kernel sistem operasi. Secara umum, user level thread
lebih cepat dalam pembuatan dan pengelolaan dari pada kernel thread. Ada tiga
perbedaan tipe dari model yang berhubungan dengan user dan kernel thread.

 Model many to one: memetakan beberapa user level thread hanya ke satu
buah kernel thread.
 Model one to one: memetakan setiap user thread ke dalam satu kernel
thread. berakhir.
 Model many to many: mengizinkan pengembang untuk membuat user
thread sebanyak mungkin, konkurensi tidak dapat tercapai karena hanya
satu thread yang dapat dijadualkan oleh kernel dalam satu waktu.

Java adalah unik karena telah mendukung thread didalam tingkatan bahasanya.
Semua program Java sedikitnya terdiri dari kontrol sebuah thread tunggal dan
mempermudah membuat kontrol untuk multiple thread dengan program yang
sama. JAVA juga menyediakan library berupa API(Application Program
Interface) untuk membuat thread, termasuk method untuk suspend dan resume
suatu thread, agar thread tidur untuk jangka waktu tertentu dan menghentikan
thread yang berjalan. Sebuah java thread juga mempunyai empat kemungkinan
keadaan, diantaranya: New, Runnable, Blocked dan Dead. Perbedaan API untuk
mengelola thread seringkali mengganti keadaan thread itu sendiri.
 P a g e | 31

DAFTAR PUSTAKA

J.E.N.I. -. Pengenalan Pemrograman 2. Jakarta: Jardiknas.

Gata, Windu. 2005. Bahasa Pemrograman Java Gui, Error Exception,

Thread, I/O (Input/Output), Database & Pembuatan Laporan.
Jakarta:-.

Silberschatz, Abraham, Peter Baer Galvin, dan Greg Gagne. 2005. Operating
System Concepts. Seventh Edition. USA: John Wiley & Sons, Inc.

www.java.lyracc.com/belajar/java-untuk-pemula/dasar-dasar-thread.