Thread merupakan bagian program yang dapat dijalankan secara independen. Dokumen ini membahas konsep dasar thread programming pada Java, termasuk pengertian thread, keuntungan dan kerugian multithreading, model-model multithreading, pustaka thread, pembatalan thread, penggunaan thread pool, penjadwalan thread, contoh pembuatan thread utama dan multi-thread.

1. KONSEP DASAR THREAD PROGRAMMING
(Mata Kuliah Komputasi Modern)
Disusun oleh:
KELOMPOK 4
1. Amalia Wulandari 50417595
2. Anugrah Cahya Agusty Satrio 50417878
3. Kurnia Jordy Adhi Pradana 53417254
4. Ni Luh Made Mita Mesdiana 54417475
5. Muhamad Renaldy Ridwan 53417795
6. Panji Maulana Al Latief 54417689
7. Rafi Mochamad Fahreza 54417857
8. Robby Nugraha 55417378
FAKULTAS TEKNOLOGI INDUSTRI
JURUSAN TEKNIK INFORMATIKA
UNIVERSITAS GUNADARMA
2021

2. KONSEP DASAR THREAD PROGRAMMING (JAVA)
1. Pengertian Thread
Thread merupakan sebuah pengontrol aliran program. Untuk lebih mudahnya,
bayangkanlah thread sebagai sebuah proses yang akan dieksekusi di dalam sebuah program
tertentu. Thread adalah suatu bagian program yang tidak tergantung pada bagian lain dan dapat
dijalankan secara bersama-sama. Hal ini berarti suatu thread dapat diberhentikan atau
diistirahatkan tanpa harus menghentikan yang lainnya. Pada Java setiap thread dikontrol oleh
suatu obyek unik turunan Thread, yang didefinisikan di dalam paket java.lang.
2. Keuntungan dan Kerugian MultiThreading
Multiprocessing merupakan penggunaan dua atau lebih CPU dalam sebuah sistem
komputer. Multitasking merupakan metode untuk menjalankan lebih dari satu proses dimana
terjadi pembagian sumberdaya seperti CPU. Multithreading adalah cara pengeksekusian yang
mengizinkan beberapa thread terjadi dalam sebuah proses, saling berbagi sumber daya tetapi
dapat dijalankan secara independen.
Keuntungan dari sistem yang menerapkan multithreading dapat kita kategorikan menjadi 4
bagian:
a. Responsif.
Aplikasi interaktif menjadi tetap responsif meskipun sebagian dari program sedang
diblok atau melakukan operasi lain yang panjang. Umpamanya, sebuah thread dari web

3. browser dapat melayani permintaan pengguna sementara thread yang lain berusaha
menampilkan gambar.
b. Berbagi sumber daya.
Beberapa thread yang melakukan proses yang sama akan berbagi sumber daya.
Keuntungannya adalah mengizinkan sebuah aplikasi untuk mempunyai beberapa thread
yang berbeda dalam lokasi memori yang sama.
c. Ekonomis.
Pembuatan sebuah proses memerlukan pengalokasian memori dan sumber daya.
Alternatifnya adalah dengan menggunakan thread, karena thread membagi memori dan
sumber daya yang dimilikinya sehingga lebih ekonomis untuk membuat thread dan
context switching thread. Akan susah mengukur perbedaan waktu antara thread dan
switch, tetapi secara umum pembuatan dan pengaturan proses akan memakan waktu lebih
lama dibandingkan dengan thread. Pada Solaris, pembuatan proses memakan waktu 30
kali lebih lama dibandingkan pembuatan thread sedangkan proses context switch 5 kali
lebih lama dibandingkan context switching thread.
d. Utilisasi arsitektur multiprosesor.
Keuntungan dari multithreading dapat sangat meningkat pada arsitektur multiprosesor,
dimana setiap thread dapat berjalan secara paralel di atas procesor yang berbeda. Pada
arsitektur processor tunggal, CPU menjalankan setiap thread secara bergantian tetapi hal
ini berlangsung sangat cepat sehingga menciptakan ilusi paralel, tetapi pada
kenyataannya hanya satu thread yang dijalankan CPU pada satu-satuan waktu.
Adapun kerugian dari multithreading adalah :
1. Jika digunakan secara berlebihan, multithreading akan berdampak pada pemborosan
resource dan CPU yang dialokasikan untuk switching threads. Misalnya jika heavy disk
I/O terlibat, akan lebih cepat jika hanya memiliki 1 atau 2 thread yang melaksanakan
tugas secara berurutan, daripada menggunakan multithread yang masing-masing
mengeksekusi sebuah task pada waktu yang sama.
2. Sistem yang memiliki kecepatan prosesor dan memory yang cenderung sama, sehingga
tidak ada efisiensi yang hilang (mengacu kepada latency), tidak akan memperoleh
peningkatan bandwidth yang signifikan jika menggunakan multithreading.

4. 3. Multithreading menghasilkan program yang lebih kompleks. Menggunakan multiple
thread sendiri tidak akan menciptakan kerumitan, tapi interaksi antar thread-lah yang
mengakibatkan kompleksitas tersebut.
4. Thread yang banyak bisa saling berinterferensi ketika saling berbagi sumber daya
hardware seperti cache.
3. Model MultiThreading
Beberapa terminologi yang akan dibahas:
a. Thread pengguna.
Thread yang pengaturannya dilakukan oleh pustaka thread pada tingkatan pengguna.
Karena pustaka yang menyediakan fasilitas untuk pembuatan dan penjadwalan thread,
thread pengguna cepat dibuat dan dikendalikan.
b. Thread Kernel.
Thread yang didukung langsung oleh kernel. Pembuatan, penjadwalan dan
manajemen thread dilakukan oleh kernel pada kernel space. Karena dilakukan oleh
sistem operasi, proses pembuatannya akan lebih lambat jika dibandingkan dengan
thread pengguna.

5. Model-Model MultiThreading:
a. Model Many-to-One.
Model ini memetakan beberapa thread tingkatan pengguna ke sebuah thread.
tingkatan kernel. Pengaturan thread dilakukan dalam ruang pengguna sehingga
efisien. Hanya satu thread pengguna yang dapat mengakses thread kernel pada satu
saat. Jadi Multiple thread tidak dapat berjalan secara paralel pada multiprosesor.
Kekurangannya adalah ketika ada satu blocking systemc call, semua akan menjadi
terblok juga. Contoh: Solaris Green Threads dan GNU Portable Threads.
b. Model One-to-One.
Model ini memetakan setiap thread tingkatan pengguna ke setiap thread. Ia
menyediakan lebih banyak concurrency dibandingkan model Many-to-One.
Keuntungannya sama dengan keuntungan thread kernel. Kelemahan model ini ialah
setiap pembuatan thread pengguna memerlukan tambahan thread kernel. Karena itu,
jika mengimplementasikan sistem ini maka akan menurunkan kinerja dari sebuah
aplikasi sehingga biasanya jumlah thread dibatasi dalam sistem. Contoh: Windows
NT/XP/2000 , Linux, Solaris 9, OS/2.
c. Model Many-to-Many.
Model ini memultipleks banyak thread tingkatan pengguna ke thread kernel yang
jumlahnya sedikit atau sama dengan tingkatan pengguna. Model ini mengizinkan
developer membuat thread sebanyak yang ia mau 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 dan lebih efisien. Contoh : Solaris 2,
IRIX, HPUX.
4. Pustaka Thread
Pustaka Thread atau yang lebih familiar dikenal dengan Thread Library bertugas untuk
menyediakan API untuk programmer dalam menciptakan dan memanage thread. Ada dua cara
dalam mengimplementasikan pustaka thread:
a. Menyediakan API dalam level pengguna tanpa dukungan dari kernel sehingga
pemanggilan fungsi tidak melalui system call. Jadi, jika kita memanggil fungsi yang

6. 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.
5. Pembatalan Thread
Thread Cancellation ialah pembatalan thread sebelum tugasnya selesai. Misalnya hendak
mematikan Java Virtual Machine (JVM) pada program Java. Maka sebelum JVM dimatikan
seluruh thread yang berjalan harus dibatalkan terlebih dahulu. Contoh lain adalah pada 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:
a. Asynchronous cancellation. Suatu thread seketika itu juga membatalkan target thread.
b. Deferred cancellation. Suatu thread secara periodik memeriksa apakah ia 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 hendak dibatalkan. Tetapi pembatalan hanya akan terjadi jika target thread
memeriksa apakah ia harus batal atau tidak. Hal ini memperbolehkan thread untuk memeriksa

7. apakah ia harus batal pada waktu dimana ia 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.
6. Thread Pools
Pada web server yang menerapkan multithreading ada dua masalah yang timbul:
a. Ukuran waktu yang diperlukan untuk menciptakan thread yang melayani permintaan
yang diajukan pada kenyataannya thread dibuang seketika sesudah ia menyelesaikan
tugasnya.
b. Pembuatan thread yang tidak terbatas jumlahnya dapat menurunkan performa dari sistem.
Solusinya adalah dengan penggunaan Thread Pools, yaitu sekumpulan thread yang
mengantri untuk mengerjakan tugas Cara kerjanya adalah dengan membuat beberapa thread pada
proses startup dan menempatkan mereka ke pools, dimana mereka duduk diam dan menunggu
untuk bekerja. Jadi, ketika server menerima permintaan, ia akan membangunkan thread dari pool
dan jika thread tersedia maka permintaan tersebut akan dilayani. Ketika thread sudah selesai
mengerjakan tugasnya maka ia kembali ke pool dan menunggu pekerjaan lainnya. Bila tidak ada
thread yang tersedia pada saat dibutuhkan maka server menunggu sampai ada satu thread yang
bebas.
Keuntungan thread pool adalah:
a. Biasanya lebih cepat untuk melayani permintaan dengan thread yang ada
dibandingkan menunggu thread baru dibuat.
b. Thread pool membatasi jumlah thread yang ada pada suatu waktu. Hal ini penting
pada sistem yang tidak dapat mendukung banyak thread yang berjalan secara
concurrent. Jumlah thread dalam pool dapat tergantung dari jumlah CPU dalam sistem,
jumlah memori fisik, dan jumlah permintaan klien yang concurrent.
c. Pembuatan jumlah thread yang tepat dapat meningkatkan performa serta sistem yang
lebih stabil

8. 7. Penjadwalan Thread
Begitu dibuat, thread baru dapat dijalankan dengan berbagai macam penjadwalan.
Kebijakan penjadwalanlah yang menentukan setiap proses, di mana proses tersebut akan ditaruh
dalam daftar proses sesuai proritasnya dan bagaimana ia bergerak dalam daftar proses tersebut.
Untuk menjadwalkan thread, sistem dengan model multithreading many to many atau
many to one menggunakan:
a. Process Contention Scope (PCS). 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).

9. 8. Contoh Thread Utama
class ThreadUtama {
public static void main(String[] args) throws InterruptedException {
// mendapatkan thread yang sedang aktif
Thread tUtama = Thread.currentThread();
// menampilkan informasi tentang thread
System.out.print("Informasi thread: ");
System.out.println(tUtama.toString());
for (int i=0; i<5; i++) {
System.out.println("Detik ke-" + (i+1));
Thread.sleep(1000); // membuat delay selama 1 detik
}
}
}
Pada contoh 1 di atas, thread dengan nama ThreadUtama. Variabel ini digunakan untuk
menangkap thread utama yang sedang berjalan pada program dengan perintah
Thread.currentThread(). Kemudian informasi tentang thread ini tampilkan di layar. Pada baris
yang dimulai dengan for, akan menggunakan perintah untuk mengontrol thread yang sedang
berjalan. Menggunakan method sleep untuk mengontrol thread agar menunda pekerjaan selama
1 detik tiap kali pengulangan.
9. Pembuatan dan Penggunaan Thread
Thread dapat dibuat dengan dua cara yaitu dengan membuat kelas baru yang menerapkan
interface Runnable dan membuat kelas baru dengan menurunkan dari kelas Thread. Kedua cara
tersebut membutuhkan paket java.lang. Secara default paket ini telah otomatis diimpor pada saat
kita membuat program dengan Java.
Contoh 2membuat thread dengan interface Runnable
class TestRunnable implements Runnable {
// mengimplementasikan method run() yang dideklarasikan
// di dalam interface Runnable public void run() {
System.out.println("Thread anak dieksekusi");
}}
class PenerapanRunnable {
public static void main(String[] args) {
// (LANGKAH KE-1): membuat objek Runnable
TestRunnable obj = new TestRunnable();
// (LANGKAH KE-2): membuat objek Thread dengan melewatkan objek Runnable
Thread t = new Thread(obj)
// (LANGKAH KE-3) : menjalankan thread
t.start();
System.out.println("Thread utama dieksekusi");
}}
Pada contoh di atas membuat lebih dulu kelas TestRunnable yang menerapkan Runnable
(perhatikan baris class TestRunnable implements Runnable dan blok kode

10. dibawahnya). Kemudian membuat obyek TestRunnable dari kelas tersebut (lihat pada baris
TestRunnable obj = new TestRunnable() ). Obyek ini digunakan untuk membuat thread baru
dengan cara menggunakan constructor kelas thread (lihat baris Thread t = new Thread(obj) ).
Setelah terbentuk maka dapat menjalankan thread tersebut (lihat baris t.start() ).
10. Multi-Thread
Pada contoh 1 dan 2, hanya berhubungan dengan satu dan dua thread. Namun
sesungguhnya Java member kemungkinan untuk membuat lebih dari dua thread. Kondisi ini
dinamakan sebagai Multi-thread.
Contoh 3. Membuat multi-thread
class MyThread1 extends Thread { public void run() {
try {
for (int i=0; i<10; i++) {
System.out.println("Thread pertama: detik ke-" +
(i+1)); if (i != 9) { sleep(1000);
} else {
System.out.println("Thread pertama selesai...n");
}
}
} catch (InterruptedException ie) {
System.out.println(ie.getMessage());
}
}
}
class MyThread2 extends Thread { public void run() {
try {
for (int i=0; i<5; i++) {
System.out.println("Thread kedua: detik ke-" +
(i+1));
if (i != 4) { System.out.println(); sleep(1000);
} else {
System.out.println("Thread kedua selesai...n");
}
}
} catch (InterruptedException ie) {
System.out.println(ie.getMessage());
}}}
class DemoMultipleThread {
public static void main(String[] args) {
MyThread1 t1 = new MyThread1(); t1.start();
MyThread2 t2 = new MyThread2(); t2.start();
}}
Kode program di atas menunjukkan bagaimana membentuk dua buah thread. Thread yang
pertama melalui pembuatan kelas MyThread1 dengan cara menurunkan kelas Thread. Cara ini
adalah cara kedua membuat thread di bagian sebelumnya. Thread kedua dengan nama kelas

11. dengan cara yang sama. Kemudian pada class DemoMultipleThread membuat obyek t1 dari
kelas MyThread1 dan obyek t2 dari kelas MyThread2. Apabila dijalankan, kode program di atas
akan tampak seperti pada Gambar dibawah ini
.