Sinkronisasi dan Deadlock

OLEH:

M. Ismail (19076011)

PROGRAM STUDI PENDIDIKAN TEKNIK INFORMATIKA

JURUSAN ELEKTRONIKA

FAKULTAS TEKNIK

UNIVERSITAS NEGERI PADANG

2020

1
 KATA PENGANTAR

Puji dan syukur penulis panjatkan ke hadirat Allah SWT karena berkat Rahmat dan
Hidayah-Nya, serta segala kemudahan yang telah diberikan, penulis dapat menyelesaikan
tugas akhir dari matakuliah “Sistem Operasi”, tugas akhir ini membahas sesuai dengan
judulnya yaitu Sinkronisasi dan Deadlock.
Adapun tujuan pembuatan tugas akhri semester ini adalah untuk memenuhi nilai ujian
akhir semester serta membantu para mahasiswa untuk mencari referensi yang tepat dalam
mempelajari mata kuliah Sistem Operasi. Buku ajar ini membahas tentang sinkronisasi dan
deadlock.
Penulis menyadari bahwa buku ini masih banyak kekurangan, karena itu penulis
mengharapkan masukan yang positif agar di kemudian hari dapat memperbaiki kekurangan
buku ini. Semoga buku ini dapat memberikan manfaat bagi para pembacanya.

2
 DAFTAR ISI

Contents
KATA PENGANTAR ............................................................................................................................ 2
BAB I ...................................................................................................................................................... 4
PENDAHULUAN .................................................................................................................................. 4
A. LATAR BELAKANG ................................................................................................................ 4
B. RUMUSAN MASALAH ............................................................................................................ 4
BAB II..................................................................................................................................................... 5
PEMBAHASAN ..................................................................................................................................... 5
A. SINKRONISASI ......................................................................................................................... 5
1. Definisi Sinkronisasi ............................................................................................................... 5
2. Tujuan Sinkronisasi ................................................................................................................ 5
3. Race Condition........................................................................................................................ 5
4. Problem Critical Section ......................................................................................................... 6
5. Perangkat Sinkronisasi ............................................................................................................ 8
B. DEADLOCK............................................................................................................................... 9
1. Deifinisi Deadlock .................................................................................................................. 9
2. Daur Ulang Sumber Daya ..................................................................................................... 10
3. Sumber Daya Sekali Pakai .................................................................................................... 11
4. Kondisi untuk Terjadinya Deadlock ..................................................................................... 12
5. Mengabaikan Masalah Deadlock .......................................................................................... 12
6. Mendeteksi dan Memperbaiki ............................................................................................... 12
7. Menghindari Deadlock.......................................................................................................... 14
8. Pencegahan Deadlock ........................................................................................................... 14
BAB III ................................................................................................................................................. 16
PENUTUP ............................................................................................................................................ 16
A. Kesinpulan ................................................................................................................................ 16
DAFTAR ISI............................................................................................................................................. 17

3
 BAB I

PENDAHULUAN

A. LATAR BELAKANG
Pada sistem operasi sering kali terjadi beberapa hal seperti berikut:
1. Akses-akses yang dilakukan secara bersama-sama ke data yang sama, dapat
menyebabkan data menjadi tidak konsisten.
2. Untuk menjaga agar data tetap konsisten, dibutuhkan mekanisme-mekanisme
untuk memastikan pemintaan ekseskusi dari proses yang bekerja.
3. Race Condition: Situasi dimana beberapa proses mengakses dan memanipulasi
data secara bersamaan. Nilai terakhir dari data bergantung dari proses mana yang
selesai terakhir.
4. Untuk menghindari Race Condition, proses-proses secara bersamaan harus
disinkronisasikan.
Misalkan pada suatu komputer terdapat dua buah program, sebuah tape drive
dan sebuah printer. Program A mengontrol tape drive, sementara program B
mengontrol printer. Setelah beberapa saat, program A meminta printer, tapi printer
masih digunakan. Berikutnya, B meminta tape drive, sedangkan A masih mengontrol
tape drive. Dua program tersebut memegang kontrol terhadap sumber daya yang
dibutuhkan oleh program yang lain. Tidak ada yang dapat melanjutkan proses masing-
masing sampai program yang lain memberikan sumber dayanya, tetapi tidak ada
yang mengalah. Kondisi inilah yang disebut Deadlock atau pada beberapa buku
disebut Deadly Embrace Deadlock yang mungkin dapat terjadi pada suatu proses
disebabkan proses itu menunggu suatu kejadian tertentu yang tidak akan pernah
terjadi. Dua atau lebih proses dikatakan berada dalam kondisi deadlock, bila setiap
proses yang ada menunggu suatu kejadian yang hanya dapat dilakukan oleh proses
lain dalam himpunan tersebut.

B. RUMUSAN MASALAH
1) Apa itu yang dimaksud dengan Sinkronisasi dan Deadlock?
2) Bagaimana cara untuk mengatasi Sinkronisasi dan Deadlock?

4
 BAB II

PEMBAHASAN

A. SINKRONISASI

1. Definisi Sinkronisasi
Seperti yang telah kita ketahui proses dapat bekerja secara sendiri
(independent process) maupun bersamaan dengan proses-proses lainnya
(Cooperating process). Ketika proses berjalan bersamaan (Cooperating process)
maka proses dapat saling berbagi data, sehingga dapat mengakibatkan data
tersebut di bersifat konsisten dikarenakan adanya kemungkinan akses yang
dilakukan secara bersamaan sehingga membuat data tersebut dapat berubah, hal
tersebut disebut dengan Race Condition.
Sinkronisasi merupakan pengaturan jalannya beberapa proses pada waktu
yang bersamaan, agar tidak terjadinya inconsitensi (ketidak konsistenan) data
yang diakibatkan akses data yang besamaan, dengan kata lain konsisten
diperlukan agar data tetap konsisten.

2. Tujuan Sinkronisasi
Tujuan dari Sinkornisasi seperti yang dijelaskan sebelumnya yaitu, agar tidak
terjadi ketidak konsistenan data yang diakibatkan akses data yang bersamaan,
serta untuk dapat mengatur jalannya proses yang dilakukan dalam waktu yang
bersamaan. Adapun manfaat dari adanya sinkronisasi pada sistem operasi
komputer adalah:
1) Adanya akses-akses data yang sama secara besamaan bisa saja mengakibatkan
ketidak konsistenan data.
2) Agar data yang ada tetap konsisten membutuhkan mekanisme-mekanisme agar
dapat dipastikan proses eksekusi berjalan.
3) Adanya Race Condition yang merupakan keadaan dimana terdapat proses
mengakses dan memanipulasi data secara bersamaan, dan membuat nilai
akhirnya bergantung pada akses yang duluan berhenti.

3. Race Condition
Race Condition yang merupakan keadaan dimana terdapat proses mengakses
dan memanipulasi data secara bersamaan, dan membuat nilai akhirnya bergantung

5
 pada akses yang selesai pertama. Untuk menghindari kejadian tersebut maka perlu
disinkronisasikan.
` Dalam sebuah sistem terdapat cooperating sequential process yang bejalan
secara asynchronous dan berbagi data yang sama. Untuk lebih jelansya perhatikan
contoh program java berikut yang memperlihatkan adanya Race Condition.

Pada program di atas pada baris 12 dan 23 terdapat perintah dari counter++
dan counter-— yang dieksekusi secara bersamaan maka membuat nilai akhir
dari counter itu sendiri menjadi tidak konsisten. Coba perhatikan contoh
berikut:

Pada contoh di atas menyatakan bahwa counter memiliki dua buah nilai
yaiut bernilia tiga (saat counter++ dijalankan) dan bernilai satu (saat
counter-- dijalankan). Kejadian tersebut menyebabkan nilai counter tidak
konsisten. Perhatikan bahwa nilai dari counter akan bergantung dari perintah
counter yang terakhir dijalankan. Sehingga kita membutuhkan sinkronisasi
yang merupakan upaya agar proses-proses yang saling berkerja bersama-sama
dijalankan secara berurutan demi mencegah adanya keadaan Race Condition.

4. Problem Critical Section

Pada umumnya dalam suatu proses akan lebih sering melakukan perhitungan
internal dan hal-hal teknis lainnya tanpa ada bahaya Race Condition di sebagian

6
besar waktu. Tetapi, pada beberapa proses memiliki segmen kode ketika
dijalankan maka proses-proses tersebut dapat saling merubah variabel yang ada,
meng-update suatu table, menulis ke dalam file, dan lain sebagainya. Beberapa hal
inilah yang dapat membuat proses menimbulkan adanya Race Conditon, dan
segmen kode yang dapat mengakibatkan hal ini disebut Critical Section.
Untuk menghidari timbulnya race condition serta keadaan-keadaan lainnya
yang melibatkan pemakaian memori bersama, berkas bersama serta sumber daya
yang digunakan bersama-sama adalah mencega proses read dan write secara
bersamaan pada sebuah data. Atau dapat juga disebut dengan Mutual Exlusion,
yang merupakan suatu cara yang menjamin jika ada sebuah proses yang
menggunakan variabel atau berkas yang sama (digunakan juga oleh proses lain),
maka proses lain akan dikeluarkan dari pekerjaan yang sama.
Maka Critical Section dapat dikatakan sebagai sebuah segmen kode pada
sebuah proses memiliki sumber daya bersama yang diakses teridir dari:
1) Entry Section, merupakan kode yang digunakan untuk masuk ke dalam citical
section.
2) Crittical Section, merupakan kode yang hanya memiliki satu proses yang
dapat di proses pada satu waktu.
3) Exit Section, merupakan akhir dari critical section, yang mengizinkan proses
lain.
4) Remainder Section, merupakan kode istirahat setelah masuk ke critical
section.
Solusi untuk menyelesaikan critical section adalah dengan merancang sebuah
protokol di mana proses-proses dapat menggunakan secara bersama-sama. Setiap
proses harus meminta izin untuk untuk memasuki critical section-nya. Kode dari
bagian izin disebut entry section. Akhir dari critcal section itu disebut exit
section. Bagian selanjutnya disebut remainder section. Beriktu contohnya:

Dari kode di atas, untuk memasuki critical section harus melalui entry section.
Menurut Silbeschatz (2004) solusi dari masalah critical section harus
memenuhi tiga syarat berikut:

7
 1) Mutual Exclusion. Jika suatu proses yang sedang menjalankan critical
section-nya, maka proses-proses tidak dapat menjalankan critical section-nya.
Dengan kata lain, tidak ada dua proses yang berada pada critical section pada
waktu yang sama.
2) Terjadi kemajuan (progress). Jika tidak ada proses yang sedang menjalankan
critical section-nya dan ada proses lain yang ingin masuk pada critical
section, maka hanya proses yang sedang ada pada critical section yang dapat
menyelesaikan critical section.
3) Ada batas waktu tunggu (bounded waiting). Jika ada proses yang sedang
menjalankan critical section, maka proses lain memiliki waktu tunggu yang
memiliki batas untuk mejalankan critical section-nya, sehingga dapat
dipastikan proses tersebut dapat mengjalankan critical section-nya.(tidak
mengalami starvation: proses seolah-olah berhenti, menunggu giliran akses
ke critical section diperbolehkan).

5. Perangkat Sinkronisasi
1) Processor Synchronous
Central Processing Unit (CPU) mempunyai suatu mekanisme yang disebut
interupsi. Mekanisme ini banya diterapkan dalam sistem operasi, sebagai
contoh: system call, process scheduling, dan lain sebagainya.
Sistem time-shared yang sering diimplementasikan dengan algoritma RR
(Round Robin), memanfaatkan mekanisme interupsi yang terdapat pada di
CPU. Sehingga di dalam RR ada suatu satuan waktu yang dinamakan
kuantum, apabila setiap kuantum dibatasi oleh interupsi perangkat lunak.

2) Memory Synchronous
Dilihat dari nama mekanismenya, maka kita sudah dapat memprediksi bahwa
mekanisme ini menggunakan jasa dari memori. Hal tersebut benar adanya,
mekanisme memory synchronous memakai suatu nilai yang disimpan di dalam
memori, dan jika suatu proses berhasil mengubah nilai ini, maka proses
tersebut akan meneruskan ke instruksi selanjutnya. Tetapi jika tidak, maka
proses ini akan berusaha terus untuk mengubah nilai tersebut.

8
B. DEADLOCK

1. Deifinisi Deadlock
Deadlock secara sederhana arti sebenarnya adalah kebutuhan. Kemudian
kebutuhan yang dimaksud dalam sistem operasi adalah bekebutuhan proses. Jadi
DeadLock adalah suatu proses dimana tidak dapat berjalan lagi atau pun tidak
terdapat komunikasi lagi atara proses.
DeadLock disebabkan karena proses yang satu menunggu sumber daya yang
sedang dijalankan proses lain yang juga sedang menunggu sumber daya yang
dijalankan oleh proses tersebut.
Dengan kata lain setiap proses dalam set menunggu untuk sumber yang hanya
dapat dikerjakan oleh proses lain dalam set yang sedang menunggu. Berikut
gambar dari contohnya:

Yang ada pada disisi kiri jembatan tidak dapat melaju karena terjadi Deadlock
ditengah jembatan. Contoh lainnya:

Dalam gambar menunjukkan setiap mobil bergerak esuai nomor yang

ditentukan, tetapi tanpa adanya pengaturan yang benar, maka setiap mobil akan
bertemu pada satu tik yang permanen atau dapat dikatakan bahwa setiap mobil
tidak menjalankan perjalanan lagi atau dengan kata lain terjadi Deadlock.
Beriktu adalah contoh dari lalulintas pada program java:
public class Proses {

9
 public synchronized void getA() {
//proses untuk mendapat sumber daya a
}
public synchronized void getB(){
//proses untuk mendapat sumber daya b
}
public void releaseA(){
//proses untuk melepaskan sumber daya a
}
public void releaseB(){
//proses untuk melepaskan sumber daya b
}
}
public class Coba {
public static void main(String [] args) {
Proses P = new Proses();
Proses Q = new Proses();
P.getA();
Q.getB();
P.getB();
Q.getA();
}
}
Merikut penjelasan dari program di atas: Tanpa adana perintah untuk
melepaskan artiny saat P mendapatkan A dan Q mendapatkan B, tetapi tidak
dilepaskan, maka saat P minta B dan Q minta A, maka keduanya akan saling
menunggu hingga salah satu melepaskan sumber dayanya, sedangkan kebutuhan P
ada pada Q dan Q ada pada P, sehingga terjadi Deadlock. Secara umum kejadian
ini dapat mudah terjadi dalam pemrograman multithread. Sebab ada kemungkinan
lebih besar untuk menggunakan sumber daya bersama.

2. Daur Ulang Sumber Daya

Kejadian Deadlock tidak lepas dari sumber daya, seperti kita lihat dari contoh
di atas, bahwa hampir seluruh merupakan masalah sumber daya yang digunakan
bersama-sama. Oleh karena itu, kita juga perlu tahu tentang jenis sumber daya,
yaitu: sumber daya dapat digunakan lagi berulang-ulang dan sumber daya yang
dapat digunakan dan habis dipakai atau dapat dikatakan sumber daya sekali pakai.
Sumber daya ini tidak habis dipakai oleh proses mana pun.Tetapi setelah
proses berakhir, sumber daya ini dikembalikan untuk dipakai oleh proses lain
yang sebelumnya tidak kebagian sumber dayaini. Contohnya prosesor, kanal M/K,
disk, semafor. Contoh peran sumber daya jenis ini pada terjadinya Deadlock ialah
misalnya sebuah proses memakai disk A dan B, maka akan terjadi Deadlock jika
setiap proses sudah memiliki salah satu disk dan meminta disk yang lain. Masalah
ini tidak hanya dirasakan oleh pemrogram tetapi oleh seorang yang merancang
sebuah sistem operasi.

10
 Cara yang digunakan pada umumnya dengan cara memperhitungkan dahulu
sumber daya yang digunakan oleh proses-proses yang akan menggunakan sumber
daya tersebut. Contoh lain yang menyababkan Deadlock dari sumber yang dapat
dipakai berulang-ulang ialah berkaitan dengan jumlah proses yang memakai
memori utama. Contoh progamnya:
//dari kelas proses kita tambahkan method yaitu meminta
public void meminta (int banyakA) {
//meminta dari sumber daya a
if ( banyakA < banyak )
banyak = banyak - banyakA;
else
wait();
}
//mengubah kode pada mainnya sebagai berikut
public static void main ( String [] args ) {
Proses P = new Proses();
Proses Q = new Proses();
P.meminta(80);
Q.meminta(70);
P.meminta(60);
Q.meminta(80);
}
private int banyak = 200;
private int banyakA;

Setelah proses P dan Q telah melakukan fungsi meminta untuk pertama kali,
maka sumber daya yang tersedia dalam banyak ialah 50 (200-70-80). Maka saat P
menjalankan fungsi meminta lagi sebanyak 60, maka P tidak akan menemukan
sumber daya dari banyak sebanyak 60, maka P akan menunggu hingga sumber
daya yang diminta dipenuhi. Demikian juga dengan Q, akan menunggu hingga
permintaannya dipenuhi, akhirnya terjadi Deadlock. Cara mengatasinya dengan
menggunakan memori maya.

3. Sumber Daya Sekali Pakai

Dalam kondisi ini biasa tidak memiliki batasan untuk menggunakan sumber
daya yang ada, selain itu karena tidak terbatasnya produksi akan membuat banyak
sumber daya yang tersedia. Tetapi kondisi ini juga dapat menyebabakan
Deadlock, contohya:
//menambahkan method receive dan send
public void receive( Proses p ){
//method untuk menerima sumber daya
}
public void send ( Proses p ){
//method untuk memberi sumber daya
}
Dari kedua fungsi tersebut ada yang bertindak untuk menerima dan memberi
sumber daya, tetapi ada kalanya proses tidak mendapatkan sumber daya yang
dibuat sehingga terjadi blok, karena itu terjadi Deadlock, tentu saja hal ini sangat

11
 jarang terjadi mengigat tidak ada batasan untuk memporduksi dan mengkonsumsi,
tetapi ada suatu keadaan seperti ini yang mengakibatkan Deadlock.

4. Kondisi untuk Terjadinya Deadlock

Ada empat kondisi yang dapat menyebabkan terjadinya deadlock. Keempat
kondisi tersebtu dapat berdiri sendiri, saling mendukung.
1) Muntual Eksklusif. Hanya ada satu proses yang boleh memakai sumber daya,
dan proses lain yang ingin memakai sumber daya tersebut harus menunggu
sumber daya tadi dilepaskan atau tidak ada porses yang memakai sumber daya
tersebut.
2) Memegang dan Menunggu. Proses yang sedang menjalankan atau memakai
sumber daya bisa meminta sumber daya lagi maksudnya menunggu hingga
benar-benar sumber daya yang diminta tidak dipakai oleh proses lain, hal ini
dapat menyebabkan kekurangan sumber daya sebab dapat saja sebuah proses
tidak mendapat sumber daya dalam waktu yang lama.
3) Tidak ada Preemtion. Sumber daya yang ada pada sebuah proses tidak boleh
diambil begitu saja oleh proses lainnya. Untuk mendapatkan sumber daya
tersebut, maka harus dilepaskan terlebih dahulu oleh proses yang
memegangnya, selain itu seluruh proses mengunggu dan mempersiapkan
hanya proses yang memiliki sumber daya yang boleh berjalan.
4) Cirular Wait. Kondisi seperti rantai, yaitu sebuah proses membutuhkan smber
daya yang dipengan proses berikutnya.

5. Mengabaikan Masalah Deadlock

Dalam metode ini bisa disebut dengan Algoritma Ostrich. Dalam algoritma ini
dikatakan bahwa untuk menghadapi Deadlock adalah dengan berpura-pura tidak
ada masalah apa pun. Hal ini membuat seakan-akan melakukan suatu hal yang
fatal, tetapi sistem operasi Unix menanggulangi Deadlock dengan cara ini tidak
mendeteksi Deadlock dan membiarkannya secara otomatis mematikan penuh,
sehingga proses yang menjalankan proses melalui operator harus menunggu pada
waktu tertentu dan mencoba lagi.

6. Mendeteksi dan Memperbaiki

Jika sebuah sistem tidak memastikan Deadlock terjadi, dan juga tidak
didukung dengan pendeteksian deadlock serta pencegahannya, maka kita akan
sampai pada kondisi deadlock yang dapat berpengaruh terhadap performance

12
sistem karena sumber daya tidak dapat digunakan oleh proses sehingga proses-
proses yang lain juga terpengaruh. Akhirnya sistem akan berhenti dan harus
direstart.
Hal-hal yang terjadi dalam mendeteksi adanya Deadlock adalah:
1) Permintaan sumber daya dikabulkan selama memungkinkan.
2) Sistem operasi memeriksa adakah kondisi circular wait secara periodik.
3) Pemeriksaan adanya Deadlock dapat dilakukan setiap ada sumber daya yang
hendak digunakan oleh sebuha proses.
4) Memeriksa dengan algoritma tertentu.
Ada beberapa jalan untuk kembali dari Deadlock
Lewat Preemtion
Dengan cara untuk sementara waktu menjauhkan sumber daya dari
pemakainya, dan memberikannya pada proses yang lain. Ide untuk memberi pada
proses lain tanpa diketahui oleh pemilik dari sumber daya tersebut tergantung dari
sifat sumber daya itu sendiri. Perbaikan dengan cara ini sangat sulit atau dapat
dikatakan tidak mungkin. Cara ini dapat dilakukan dengan memilih korban yang
akan dikorbankan atau diambil sumber dayanya utuk sementara, tentu saja harus
dengan perhitungan yang cukup agar waktu yang dikorbankan seminimal
mungkin. Setelah kita melakukan preemption dilakukan pengkondisian proses
tersebut dalam kondisi aman. Setelah itu proses dilakukan lagi dalam kondisi
aman tersebut.
Lewat melacak kembali
Setelah melakukan beberapa langkah preemption, maka proses utama yang
diambil sumber dayanya akan berhenti dan tidak dapat melanjutkan kegiatannya,
oleh karena itu dibutuhkan langkah untuk kembali pada keadaan aman dimana
proses masih berjalan dan memulai proses lagi dari situ. Tetapi untuk beberapa
keadaan sangat sulit menentukan kondisi aman tersebut, oleh karena itu
umumnya dilakukan cara mematikan program tersebut lalu memulai kembali
proses. Meski pun sebenarnya lebih efektif jika hanya mundur beberapa langkah
saja sampai Deadlock tidak terjadi lagi. Untuk beberapa sistem mencoba dengan
cara mengadakan pengecekan beberapa kali secara periodik dan menandai tempat
terakhir kali menulis ke disk, sehingga saat terjadi Deadlock dapat mulai dari
tempat terakhir penandaannya berada
Lewat membunuh Proses yang menyebabkan Deadlock
13
 Cara yang paling umum ialah membunuh semua proses yang mengalami
Deadlock. Cara ini paling umum dilakukan dan dilakukan oleh hampir semua
sistem operasi. Namun, untuk beberapa sistem, kita juga dapat membunuh
beberapa proses saja dalam siklus Deadlock untuk menghindari Deadlock dan
mempersilahkan proses lainnya kembali berjalan. Atau dipilih salah satu korban
untuk melepaskan sumber dayanya, dengan cara ini maka masalah pemilihan
korban menjadi lebih selektif, sebab telah diperhitungkan beberapa kemungkinan
jika si proses harus melepaskan sumber dayanya.
Kriteria seleksi korban ialah:
1) Yang paling jarang memakai prosesor
2) Yang paling sedikit hasil programnya
3) Yang paling banyak memakai sumber daya
4) Yang memiliki prioritas terkecil

7. Menghindari Deadlock
Ada dua cara untuk memastikan sumber daya aman dari Deadlock:
1) Jangan memulai proses jika proses tersebut akan membawa kita pada
Deadlock.
2) Jangan memberi kesempatan pada proses untuk meminta sumber daya lagi jika
penambahan ini akan membawa kita pada suatu keadaan Deadlock.

8. Pencegahan Deadlock
Kita akan membahas cara menggulangi keempat penyebab Deadlock itu,
sehinga dengan kata lain kita mengadakan pencegahan terhadap deadlock.
1) Masalah Mutual Eksklusif Kondisi ini tidak dapat dilarang, jika aksesnya
perlu bersifat spesial untuk satu proses, maka hal ini harus di dukung oleh
kemampuan sistem operasi. Jadi diusahakan agar tidak mempergunakan
kondisi spesial tersebut sehingga sedapat mungkin Deadlock dapat
dihindari.
2) Masalah Kondisi Menunggu dan Memegang Penanggulangan Deadlock
dari kondisi ini lebih baik dan menjanjikan, asalkan kita dapat menahan
proses yang memegang sumber daya untuk tidak menunggu sumber daya
laun, kita dapat mencegah Deadlock. Caranya ialah dengan meminta
semua sumber daya yang ia butuhkan sebelum proses berjalan. Tetapi

14
 masalahnya sebagian proses tidak mengetahui keperluannya sebelum ia
berjalan.
3) Masalah tidak ada Preemption Hal ketiga ialah jangan sampai ada
preemption pada sumber daya yang telah dialokasikan. Untuk memastikan
hal ini, kita dapat menggunakan protokol. Jadi jika sebuah proses meminta
sumber daya yang tidak dapat dipenuhi saat itu juga, maka proses
mengalami preempted. Atau dengan kata lain ada sumber daya dilepaskan
dan diberikan ke proses yang menunggu, dan proses itu akan menunggu
sampai kebutuhan sumber dayanya dipenuhi.
4) Masalah Circular Wait Masalah ini dapat ditangani oleh sebuah protokol
yang menjaga agar sebuah proses tidak membuat lingkaran siklus yang
dapat mengakibatkan Deadlock.

15
 BAB III

PENUTUP

A. Kesinpulan
Suatu proses yang bekerja bersama-sama dan saling berbagi data dapat
mengakibatkan race condition atau pengaksesan data secara besama-ama. Cirtical
section adalah segmen kode dari proses-proses itu yang memungkinkan terjadinya
critical section. Untuk mengatasi masalah critical section ini, suatu data yang sedang
diproses tidak boleh diganggu proses lain.
Sebenarnya deadlock dapat disebabkan oleh empat hal yaitu:
1. Proses Mutual Exclusion
2. Proses memegang dan menunggu
3. Proses Preemption
4. Proses Menunggu dengan siklus deadlock tertentu
Penanganan deadlock deadlock:
1. mengabaikan masalah deadlock.
2. mendeteksi dan memperbaiki
3. penghindaran yang terus menerus dan pengalokasian yang baik.
4. pencegahan yang secara struktur bertentangan dengan empat kondisi terjadinya
deadlock.
Deadlock adalah suatu kondisi dimana sekumpulan proses tidak dapat berjalan
kembali akibat kompetisi memperebutkan sumber daya.
Sebuah proses berada dalam keadaan deadlock apabila semua proses berada
dalam keadaan menunggu (di dalam waiting queue) peristiwa yang hanya bisa
dilakukan oleh proses yang berada dalam waiting queue tersebut.

16
 DAFTAR ISI
Hartono, dkk. 2018. SISTEM OPERASI: Buku Referensi Informatika dan Sistem Informasi.
Aceh Utara: CV. Sefa Bumi Persada.

Masyarakat Digital Gotong Royong (MDGR). 2006. Sistem Operasi Komputer: Plus Ilustrasi
Kernel Linux. Jakarta: Universitas Indonesia.

Watrianthos, Ronal dan Iwan Purnama. 2018. Sistem Operasi. Siduarjo: Uwais Inspirasi
Indonesia.

17