MAKALAH
“SISTEM OPERASI”
Dosen Pengampu: ARIFIN A. ABD.KARIM
Disusun Oleh :
- Syahidan al-asri
- Fachru Roji Fitrah
- Ardin R Mohi
- Annas Firdaus
PRODI TEKNIK INFORMATIKA
UNIVERSITAS NAHDLATUL ULAMA INDONESIA
BOGOR 2020
Assalamualaikum wr.wb
Bismillahirrahmanirrahim
Puji syukur penulis panjatkan kehadirat Allah SWT, Tuhan semesta alam. Atas izin dan
karunia-Nya, kami dapat menyelesaikan makalah tepat waktu tanpa kurang suatu
apa pun. Tak lupa pula penulis haturkan shalawat serta salam kepada junjungan
Rasulullah Muhammad SAW. Semoga syafaatnya mengalir pada kita di hari akhir
kelak.
Penulisan makalah berjudul “system operasi” bertujuan untuk memenuhi tugas mata
kuliah system operasi.
Selama proses penyusunan makalah, penulis mendapatkan bantuan dan bimbingan
dari beberapa pihak. Oleh karena itu, penulis berterima kasih kepada:
1.ARIFIN A. ABD.KARIM
Akhirul kalam, penulis menyadari bahwa makalah ini masih jauh dari sempurna. Besar
harapan penulis agar pembaca berkenan memberikan umpan balik berupa kritik dan
saran. Semoga makalah ini bisa memberikan manfaat bagi berbagai pihak. Aamiin.
Wassalamualaikum wr.wb
Daftar Isi
HALAMAN JUDUL …………………………… i
KATA PENGANTAR ………………………… ii
DAFTAR ISI ………………………………… iii
BAB I PENDAHULUAN ……………………… 1
A. Latar Belakang ………………………………………….. 1
BAB II PEMBAHASAN …………………………. 2
A. Pengertian Thread…………………………………… 2
B. Jenis-jenis proses Thread ……………………………………..
BAB III PENUTUP …………………………………… 26
A. Simpulan …………………………………………………… 30
DAFTAR PUSTAKA ………………………………… 32
BAB I
PENDAHULUAN
A.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 bagianbagian 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.
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.
BAB II
PEMBAHASAN
A.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
respon dari user, pembagian sumber daya proses,
meliputi peningkatan
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.
B.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 thread (terstruktur) dan hanya
mengerjakan satu tugas dalam satu waktu. Di bawah ini merupakan gambar single
thread.
3
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
....\n");
System.out.println("Race
started!\n\n");
horse1.run("horse1");
horse2.run("horse2");
horse3.run("horse3");
}
}
class raceTest{
private int pause;
Starting
private int stage=0;
public void run(String name){
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
- 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 masingmasing. 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
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");
}
}
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
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!
Keuntungan Thread
Terdapat empat keuntungan utama dari program yang multithreading, yaitu sebagai
berikut:
1. Responsiveness
Membuat aplikasi yang interaktif menjadi multithreading dapat
program terus berjalan meski pun sebagian dari
melakukan operasi yang panjang, karena
membuat sebuah
program tersebut diblok atau
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
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
secara bergantian tetapi hal ini berlangsung
ilusi pararel, tetapi pada
menjalankan setiap thread
sangat cepat sehingga menciptakan
kenyataannya hanya satu thread yang dijalankan CPU
pada satu-satuan waktu (satu-satuan waktu pada CPU biasa disebut time slice atau
quantum).
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
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 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.
Gambar 2.5. Many to Many
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
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.
Gambar 2.6. Status Thread
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.
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().
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 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
"+j);
}
System.out.println("Exit from B");
}
}
ThreadB:
j=
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");
}
}
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");
}
}
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();
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.
.
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.
Pembatalan Thread (Thread Cancellation)
Thread Cancellation ialah
pembatalan thread sebelum tugasnya
Umpamanya, jika dalam program Java hendak mematikan
selesai.
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.
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.
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).
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).
Sinkronisasi
Thread yang berjalan bersama-sama tetapi tidak bergantung satu dengan yang lainnya.
Thread tersebut adalah thread yang berjalan sendiri tanpa memperhDaftar Isi
HALAMAN JUDUL …………………………… i
KATA PENGANTAR ………………………… ii
DAFTAR ISI ………………………………… iii
BAB I PENDAHULUAN ……………………… 1
A. Latar Belakang ………………………………………….. 2
B. Rumusan Masalah ……………………………………… 2
C. Tujuan Penulisan ……………………………………….. 3
D. Manfaat Penulisan ……………………………………… 3
BAB II PEMBAHASAN …………………………. 4
A. Pengertian Erosi Air …………………………………… 4
B. Penyebab Erosi Air …………………………………….. 6
C. Dampak Erosi Air ………………………………………. 12
D. Contoh Kasus Erosi Air ………………………………. 16
E. Cara Mengatasi Erosi Air ……………………………. 20
F. Upaya Pencegahan Erosi Air ……………………….. 25
BAB III PENUTUP …………………………………… 26
A. Simpulan …………………………………………………… 30
B. Saran ………………………………………………………… 31
DAFTAR PUSTAKA ………………………………… 32
atikan 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,
str2) {
this.str1 = str1;
this.str2 = str2;
thread = new Thread(this);
thread.start();
}
public void run() {
TwoStrings.print(str1, str2);
String
}
}
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 permasalahanpermasalahan 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.
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();
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;
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 {
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++;
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
BAB III
PENUTUP
A. 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.
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.
