MAKALAH SISTEM OPERASI

SINKRONISASI PROSES

Disusun oleh :

I Gede Laksmana Yudha 1808561049 (B)

Kadek Nanda Banyu Permana 1808561050 (B)

Gede Agung Aji Andar Sakti 1808561051 (B)

Ni Made Elvina Aryadhika Putri 1808561052 (B)

Agastia Maulana Akbar 1808561053 (B)

I Made Eko Satria Wiguna 1808561054 (B)

Putu Bayu Eka Pratama 1808561055 (B)

Nathanael Richie Thomas 1808561056 (B)

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM

PROGRAM STUDI TEKNIK INFORMATIKA

2019

1
 KATA PENGANTAR

Puji dan syukur kami panjatkan kepada Tuhan Yang Maha Esa karena atas berkat dan
rahmatNya, kami bisa menyelesaikan tugas makalah yang berjudul “Manajemen Proses dalam
Sistem Operasi” dengan tepat waktu. Makalah ini disusun untuk memenuhi tugas mata kuliah
Sistem Operasi.

Makalah ini telah kami susun dengan semaksimal mungkin dan mendapatkan bantuan dari
berbagai pihak sehingga dapat memperlancar proses pembuatannya. Untuk itu kami
menyampaikan banyak terima kasih kepada semua pihak yang telah berkontribusi dalam
pembuatan makalah ini. Makalah ini dibuat dengan segala keterbatasan kami selaku penulis.
Seperti pepatah “Tiada Gading Yang Tak Retak”, penulis menyadari bahwa makalah ini masih
jauh dari kata sempurna. Oleh karena itu, penulis sangat mengharapkan masukan berupa kritik dan
saran yang membangun untuk perbaikan makalah ini di kemudian hari.
Akhir kata, penulis berharap kiranya makalah ini bermanfaat bagi kehidupan kita
khususnya dalam kehidupan masyarakat kita.

Jimbaran, 3 November 2019

Tim Penyusun

ii
 DAFTAR ISI

KATA PENGANTAR ................................................................................................................... ii

DAFTAR ISI................................................................................................................................. iii

BAB I .............................................................................................................................................. 1

1.1 Latar Belakang ............................................................................................................... 1

1.2 Rumusan Masalah .......................................................................................................... 1

1.3 Tujuan dan Manfaat ...................................................................................................... 1

2.1 Konsep Dasar Sinkronisasi ............................................................................................ 2

2.2 Perangkat Keras Sinkronisasi ....................................................................................... 4

2.3 Semaphore....................................................................................................................... 6

2.4 Masalah Klasis Sinkronisasi........................................................................................ 11

2.5 Deadlock ........................................................................................................................ 14

BAB III......................................................................................................................................... 35

3.1 Kesimpulan ................................................................................................................... 35

DAFTAR PUSTAKA .................................................................................................................. 36

iii
 BAB I

PENDAHULUAN

1.1 Latar Belakang

Sinkornisasi di perlukan untuk menghindari terjadinya ketidak konsistenan data
akibat adanya akses secara konkuren. Proses-Proses tersebut disebut konkuren jika Proses
itu ada dan berjalan pada waktu yang bersamaan. Istilah Sinkronisasi sering terdengar
ketika kita menggunakan alat elektronik. Sinkronisasi sendiri berasal dari bagian sistem
operasi.
Sistem operasi adalah perangkat lunak sistem yang bertugas untuk melakukan
kontrol dan manajemen perangkat keras serta operasi-operasi dasar sistem, termasuk
menjalankan perangkat lunak aplikasi seperti program-program pengolah kata dan
peramban web.
Jadi, agar sinkronisasi bisa berjalan, sangat di butuhkan yang namanya sistem
operasi. Dalam kehidupan sehari-hari tanpa di sadari, kita sering melakukan sinkronisasi
dalam berbagai hal. Mulai pada saat menggunakan smartphone, komputer dan lain
sebagainya.
1.2 Rumusan Masalah
1. Bagaimana konsep dasar sinkronisasi pada sistem operasi?
2. Apa saja perangkat keras sinkronisasi pada sistem operasi ?
3. Apa itu semaphore dalam sistem operasi ?
4. Apa saja masalah klasik sinkronisasi pada sistem operasi ?
5. Apa itu deadlock dalam sistem operasi ?
1.3 Tujuan dan Manfaat
1. Mengetahui konsep dasar sinkronisasi pada sistem operasi.
2. Mengetahui perangkat-perangkat keras sinkronisasi pada sistem operasi .
3. Mengetahui semaphore dalam sistem operasi .
4. Mengetahui masalah klasik sinkronisasi pada sistem operasi .
5. Mengetahui deadlock dalam sistem operasi .

1
 BAB II

PEMBAHASAN

2.1 Konsep Dasar Sinkronisasi

Konkurensi merupakan landasan umum perancangan system operasi. Proses-proses

yang kongkuren dapat sepenuhnya tak tergantung dengan lainnya tapi dapat juga saling
berinteraksi. Proses-proses yang saling berinterasi memerlukan sinkronisasi agar
terkendali dengan baik.

Proses-proses yang melakukan akses secara konkuren pada data yang digunakan
bersama-sama menyebabkan data tidak konsisten (inconsistence). Agar data konsisten
dibutuhkan mekanisme untuk menjamin eksekusi yang berurutan pada prosesproses yang
bekerja sama. Pada model shared memory untuk penyelesaian permasalahan bounded-
buffer paling banyak menyimpan n – 1 item pada buffer pada saat yang bersamaan.

Untuk mendapatkan solusi dimana semua N buffer digunakan bukan masalah yang
sederhana. Misalnya dilakukan modifikasi kode producerconsumer dengan menambahkan
variabel counter yang diinisialisasi 0 dan dinaikkan setiap satu item baru ditambahkan ke
buffer. Definisi data yang digunakan bersamasama (shared data) adalah sebagai berikut :

#define BUFFER_SIZE 10

typedef struct {

...

} item;

item buffer[BUFFER_SIZE];

int in = 0; i

nt out = 0;

int counter = 0;

2
Proses pada producer akan menambahkan satu nilai variabel counter sebagai berikut :

item nextProduced;
while (1) {
while (counter == BUFFER_SIZE)
; /* do nothing */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
counter++;
}

Sebaliknya juga proses pada consumer akan menurunkan satu nilai variabel counter
sebagai berikut :

item nextConsumed;
while (1) { while (counter == 0)
; /* do nothing */
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
counter--;
}

Pernyataan counter++ dan counter-- harus dilakukan secara atomik. Operasi atomik adalah
operasi yang harus menyelesaikan seluruh pernyataannya tanpa interupsi. Pernyataan
counter++ akan diimplementasikan dalam bahasa mesin sebagai berikut :

register1 = counter

register1 = register1 + 1

counter = register1

3
 Sedangkan pernyataan counter-- akan diimplementasikan dalam bahasa mesin sebagai
berikut :

register1 = counter

register1 = register1 + 1

counter = register1

Misalnya counter diinisialisasi 5. Pernyataan yang dijalankan adalah : producer:

register1 = counter (register1 = 5)

producer: register1 = register1 + 1 (register1 = 6)
consumer: register2 = counter (register2 = 5)
consumer: register2 = register2 – 1 (register2 = 4)
producer: counter = register1 (counter = 6)
consumer: counter = register2 (counter = 4)

Nilai counter kemungkinan bernilai 4 atau 6, sedangkan hasil yang benar seharusnya 5, hal
ini yang dimaksud dengan data yang tidak konsisten. Situasi dimana beberapa proses
mengakses dan memanipulasi data yang digunakan bersama-sama secara konkuren disebut
dengan race condition. Nilai akhir dari data yang digunakan bersama-sama tersebut
tergantung dari proses yang terakhir selesai. Untuk mencegah race condition tersebut,
proses yang konkuren harus dilakukan sinkronisasi.

2.2 Perangkat Keras Sinkronisasi

Pada sistem multiprosessor, proses-pmroses bertindak independen. Interupsi

di satu pemroses tidak mempengaruhi pemroses-pemroses yang lain. Pemroses-
pemroses yang memakai memori bersama maka pengaksesan terhadap suatu memori
dijaga pada tingkat perangkat keras agar tidak boleh pemroses lain tidak dapat
mengakses suatu lokasi yang sama di saat yang sama.

Perancang perangkat keras menyediakan instruksi-instruksi atomik yang tak

4
dapat diinterupsi. Instruksi dilaksanakan sampai selesai. Instruksi ini biasanya
dilaksanakan dengan cara mngunci bus sehingga pemroses-pemroses lain tak dapat
menggunakan bus. Pemroses yang mengunci bus dengan leluasa membaca dan/atau
memodifikasi suatu lokasi memori.

Beragam instruksi mesin disediakan oleh perancang pemroses guna membantu

implementasi mutual exclusion. Diantara instruksi-instruksi itu adalah:
 tsl (test and set lock)
 tas atau ts (test and set), digunakan IBM S/360, keluarga Motorola M68000,
dan lain-lain
 cs (compare and set), digunakan IBM 370 series
 exchange (xchg), digunakan intel X86
 dsb

A. Metode Test and Set

Metode Test and Set melakukan testing dan memodifikasi isi memori secara
atomik menggunakan fungsi Test and Set sebagai berikut :
boolean TestAndSet (boolean &target)
{
boolean rv = target; tqrget = true; return rv;
}

Untuk menyelesaikan permasalahan mutual exclusion dengan metode Test and Set
maka digunakan variable umum berikut :

boolean lock = false;

Sedangkan Process Pi mempunyai struktur sebagai berikut :

do {
while (TestAndSet(lock)) ;
critical section
lock = false;
remainder section }

5
 B. Metode Swap

Metode swap menggunakan prosedur swap untuk menukar dua variable secara
atomic. Prosedur swap adalah sebagai berikut :
void Swap(boolean &a, boolean &b) { boolean temp = a;
a = b;
b = temp;
}

Untuk menyelesaikan permasalahan mutual exclusion menggunakan prosedur swap,

variabel umum yang digunakan adalah

boolean lock; boolean waiting[n];

Kedua variable diatas diinisialisasi false. Sedangkan struktur process Pi adalah

sebagai berikut :

do {
key = true;
while (key == true) Swap(lock,key);
critical section
lock = false;
remainder section
}

2.3 Semaphore
Semaphore adalah pendekatan yang dikemukakan Dijkstra. Prinsip semaphore
adalah sebagai berikut : Dua proses atau lebih dapat bekerja sama dengan menggunakan
penanda-penanda sederhana. Proses dipaksa berhenti sampai proses memperoleh penanda
tertentu. Sembarang kebutuhan koordinasi kompleks dapat dipenuhi dengan strukstur
penanda yang sesuai kebutuhannya. Variabel khusus untuk penandaan ini disebut
semaphore.

6
 Semaphore adalah alat untuk sinkronisasi yang tidak membutuhkan busy waiting.
Semaphore S berupa variable integer. Semaphore hanya dapat diakses melalui operasi
atomic yang tak dapat diinterupsi sampai kode selesai. Operasi dari semaphore S adalah
wait dan signal berikut : wait (S):

while S≤ 0 do no-op; S--;

signal (S): S++;

Adanya semaphore mempermudah penyelesaian persoalan critical section

pada n proses. Penyelesaian critical section menggunakan semaphore menggunakan
variabel umum berikut :

semaphore mutex;

Variabel semaphore mutex diinisialisasi mutex = 1. Sedangkan struktur program

untuk proses Pi adalah : do { wait(mutex);

critical section signal(mutex);

remainder section

} while (1);

Implementasi semaphore harus dapat menjamin mutual exclusion variabel

semaphore, yaitu hanya mengijinkan satu proses pada satu saat yang boleh memanipulasi
semaphore. Implementasi sebuah semaphore menggunakan struktur data record sebagai
berikut :

typedef struct {

int value;

struct process *L;

} semaphore;

7
Pada semaphore terdapat dua operasi sederhana yaitu block untuk menghentikan
sementara proses yang menggunakan semaphore dan wakeup(P) untuk melanjutkan
eksekusi proses P yang di-blok. Operasi wait dan signal dari semaphore didefinisikan
sebagai : wait(S):

S.value--; if (S.value < 0) {

tambahkan proses ke S.L;

block;

signal(S):

S.value++;

if (S.value <= 0) {

hapus proses P dari S.L;

wakeup(P);

Sebagai alat sinkronisasi yang umum, semaphore dieksekusi oleh suatu proses
setelah proses lain. Misalnya semaphore B pada proses Pj hanya dieksekusi setelah
semaphore A dieksekusi pada proses Pi. Pada saat menggunakan semaphore, flag
diinisialisasi 0. Kode yang diakses proses Pi dan Pj dapat dilihat berikut ini :

Pi Pj

M M

A wait(flag)

signal(flag) B

8
 Semaphore merupakan salah satu sumber daya sistem. Misalnya dua proses P1
dan P2, dua sumber daya kritis R1 dan R2, proses P1 dan P2 harus mengakses kedua
sumber daya. Kondisi berikut dapat terjadi : R1 diberikan ke P1, sedang R2 diberikan
ke P2. Apabila dua proses untuk melanjutkan eksekusi memerlukan kedua sumber
daya sekaligus maka kedua proses akan saling menunggu sumber daya lain selamanya.
Tak ada proses yang dapat melepaskan sumber daya yang telah dipegangnya karena
menunggu sumber daya lain yang tak pernah diperolehnya. Kedua proses dalam
kondisi deadlock, tidak dapat membuat kemajuan apapun.

Pada saat beberapa proses membawa semaphore dan masing-masing proses

menunggu semaphore yang sedang dibawa oleh proses lain maka kemungkinan akan
terjadi deadlock. Misalnya terdapat dua semaphore S dan Q yang diinisialisasi 1.

P0 P1

wait(S); wait(Q);

wait(Q); wait(S);

signal(S); signal(Q);

signal(Q); signal(S);

Proses P0 dan P1 masing-masing menjalankan operasi wait(S) dan wait(Q). Kemudian

proses P0 dan P1 menjalankan operasi wait(Q) dan wait(S) maka sistem akan deadlock
sampai salah satu proses menjalankan operasi signal.

Apabila suatu proses tidak pernah dihapus dari antrian semaphore setelah suatu
semaphore dihentikan sementara, maka terjadi bloking yang tak terbatas. Keadaan ini
disebut starvation.

9
 Keadaan starvation digambarkan sebagai berikut. Misalnya terdapat tiga
proses P1, P2 dan P3 yang memerlukan pengaksesan sumber daya R secara periodik.
Skenario yang bisa terjadi :

• P1 sedang diberi sumber daya R, P2 dan P3 blocked menunggu sumber daya R.

• Ketika P1 keluar dari critical section, P2 dan P3 diijinkan mengakses R.
• Asumsi P3 diberi hak akses. Kemudian setelah selesai, hak akses kembali
diberikan ke P1 yang saat itu kembali membutuhkan sumber daya R.

Jika pemberian hak akses bergantian terus-menerus antara P1 dan P3, maka P2
tidak pernah memperoleh pengaksesan sumber daya R, meski tidak ada deadlock.
Pada situasi ini, P2 mengalami yang disebut Starvation.

Terdapat dua bentuk semaphore yaitu counting semaphore dan binary

semaphore. Counting semaphore menggunakan nilai integer yang mempunyai
jangkauan tak terbatas seperti pada struktur yang telah dijelanskan diatas. Binary
semaphore menggunakan nilai integer dengan jangkauan antara 0 dan 1 sehingga
implementasinya lebih sederhana. Counting semaphore S diatas dapat
diimplementasikan dengan binary semaphore. Struktur data yang digunakan adalah :
binary-semaphore S1, S2; int C:

Struktur data diatas diinisialisasi dengan

S1 = 1

S2 = 0

C = initial value of semaphore S

Implementasi operasi wait dan signal pada binary semaphore S adalah sebagai
berikut :

Operasi wait :
wait(S1); C--; if (C < 0) {
signal(S1); wait(S2);
} signal(S1);
Operasi signal :

10
 wait(S1); C ++; if (C <= 0)
signal(S2);
else
signal(S1);

2.4 Masalah Klasis Sinkronisasi

Dining-Philosopers Problem

Pada tahun 1965, Djikstra menyelesaikan sebuah masalah sinkronisasi yang beliau
sebut dengan Dining-Philisophers Problem. Dining-Philosophers dapat diuraikan sebagai
berikut: Lima orang filosof duduk mengelilingi sebuah meja bundar. Masing-masing
filosof mempunyai sepiring spageti. Spageti spageti tersebut sangat licin dan membutuhkan
dua garpu untuk memakannya. Diantara sepiring spageti terdapat satu garpu.

Kehidupan para filosof terdiri dari dua periode, yaitu makan atau berpikir. Ketika
seorang filosof lapar, dia berusaha untuk mendapatkan garpu kiri dan garpu kanan
sekaligus. Jika sukses dalam mengambil dua garpu, filosof tersebut makan untuk sementara
waktu, kemudian meletakkan kedua garpu dan melanjutkan berpikir.

Pertanyaan kuncinya adalah, dapatkah anda menulis program untuk masing-

masing filosof yang melakukan apa yang harus mereka lakukan dan tidak pernah
mengalami kebuntuan?

Prosedur take-fork menunggu sampai garpu-garpu yang sesuai didapatkan dan

kemudian menggunakannya. Sayangnya dari solusi ini ternyata salah. Seharusnya lima
orang filosof mengambil garpu kirinya secara bersamaan. Tidak akan mungkin mereka
mengambil garpu kanan mereka, maka yang terjadi adalah deadlock.

Kita dapat memodifikasi program sehingga setelah mengambil garpu kiri,

program memeriksa apakah garpu kanan memungkinkan untuk diambil. Jika garpu kanan
tidak mungkin diambil, filosof tersebut meletakkan kembali garpu kirinya, menunggu
untuk beberapa waktu, kemudia mengulangi proses yang sama. Usulan tersebut juga salah,

11
walaupun dengan alasan yang berbeda. Dengan sedikit nasib buruk, semua filosof dapat
memulai algoritma secara bersamaan, mengambil garpu kiri mereka, melihat garpu kanan
mereka yang tidak mungkin untuk diambil, meletakkan kembali garpu kiri mereka,
menunggu, mengambil garpu kiri mereka lagi secara bersamaan, dan begitu seterusnya.
Situasi seperti ini dimana semua program terus berjalan secara tidak terbatas tetapi tidak
ada perubahan/kemajuan yang dihasilkan disebut starvation.

Sekarang kita dapat berpikir "jika filosof dapat saja menunggu sebuah waktu acak
sebagai pengganti waktu yang sama setelah tidak dapat mengambil garpu kiri dan kanan,
kesempatan bahwa segala sesuatau akan berlanjut dalam kemandegan untuk beberapa jam
adalah sangat kecil." Pemikiran seperti itu adalah benar,tapi beberapa aplikasi
mengirimkan sebuah solusi yang selalu bekerja dan tidak ada kesalahan tidak seperti hsk
nomor acak yang selalu berubah.

Sebelum mulai mengambil garpu, seorang filosof melakukan DOWN di mutex.

Setelah menggantikan garpu dia harus melakukan UP di mutex. Dari segi teori, solusi ini
cukup memadai. Dari segi praktek, solusi ini tetap memiliki masalah. Hanya ada satu
filosof yang dapat makan spageti dalam berbagai kesempatan. Dengan lima buah garpu,
seharusnya dua orang filosof dapat makan spageti pada saat bersamaan.

Solusi yang diberikan di atas benar dan juga mengizinkan jumlah maksimum
kegiatan paralel untuk sebuah jumlah filosf yang berubah-ubah ini menggunakan sebuah
array, state, untuk merekam status seorang filosof apakah sedang makan (eating), berpikir
(think), atau sedang lapar (hungry) karena sedang berusaha mengambil garpu. Seorang
filosof hanya dapat berstatus makan (eating) jika tidak ada tetangganya yang sedang makan
juga. Tetangga seorang filosof didefinisikan ole LEFT dan RIGHT.

Dengan kata lain, jika i = 2, maka tetangga kirinya (LEFT) = 1 dan tetangga
kanannya (RIGHT) = 3. Program ini menggunakan sebuah array dari semaphore yang lapar
(hungry) dapat ditahan jika garpu kiri atau kanannya sedang dipakai tetangganya. Catatan
bahwa masing-masing proses menjalankan prosedur filosof sebagai kode utama, tetapi
prosedur yang lain seperti take-forks, dan test adalah prosedur biasa dan bukan proses-
proses yang terpisah

12
 Gambar 1: lima filosof dalam satu meja makan

Struktur data yang digunakan untuk penyelesaian permasalahan ini dengan

semaphore adalah

semaphore chopstick[5];

Dimana semua nilai array dinisialisasi 1. Struktur program untuk filosof ke i adalah

do {
wait(chopstick[i])
wait(chopstick[(i+1) % 5])
…
makan
…
signal(chopstick[i]);
signal(chopstick[(i+1) % 5]);
…
berfikir
…} while (1);

13
 Meskipun solusi ini menjamin bahwa tidak ada 2 tetangga yang makan bersama -
sama, namun masih mungkin terjadi deadlock, yaitu jika tiap-tiap filosof lapar dan
mengambil sumpit kiri, maka semua nilai sumpit = 0, dan jika kemudian tiap-tiap filosof
akan mengambil sumpit kanan, maka akan terjadi deadlock. Ada beberapa cara untuk
menghindari deadlock, antara lain :

a. mengijinkan paling banyak 4 orang filosof yang duduk bersama-sama pada satu
meja.
b. Mengijinkan seorang filosof mangambil supit hanya jika kedua supit itu ada
(dengan catatan, bahwa ia harus mengambil pada critical section).
Menggunakan suatu solusi asimetrik, yaitu filosof pada nomor ganjil mengambil supit
kanan dulu baru supit kiri. Sedangkan filosof yang duduk di kursi genap mengambil supit
kanan dulu baru supit kiri.

2.5 Deadlock

Deadlock adalah suatu kondisi dimana dua proses atau lebih saling menunggu
proses yang lain untuk melepaskan resource yang sedang dipakai. Karena beberapa proses
itu saling menunggu, maka tidak terjadi kemajuan dalam kerja proses-proses
tersebut. Deadlock adalah masalah yang biasa terjadi ketika banyak proses yang membagi
sebuah resource yang hanya boleh dirubah oleh satu proses saja dalam satu waktu

A. Model Sistem
Pada sistem terdapat beberapa sumber daya (resource) yang digunakan untuk proses-
proses untuk menyelesaikan task. Sumber daya yang pada sistem terdiri dari tipe resource
CPU cycle, ruang memori, perangkat I/O yang disebut dengan tipe sumber daya R1, R2, . . .,
Rm. Setiap tipe sumber daya Ri mempunyai beberapa anggota Wi. Setiap proses yang
menggunakan sumber daya menjalankan urutan operasi sebagai berikut :
B.

 meminta (request) : meminta sumber daya

14
  memakai (use) : memakai sumber daya

 melepaskan (release) : melepaskan sumber daya

C. Karakteristik Deadlock
1. Kondisi yang Diperlukan
Deadlock terjadi bila terdapat empat kondisi berikut ini secara simultan.

a. Mutual Exclusion : hanya satu proses pada satu waktu yang dapat menggunakan
sumber daya.
b. Genggam dan Tunggu (Hold and Wait) : suatu proses membawa sedikitnya satu
sumber daya menunggu mendapatkan tambahan sumber daya baru yang dibawa
oleh proses
c. Non-Preemption : sebuah sumber daya dapat dibebaskan dengan sukarela oleh proses
yang memegangnya setelah proses menyelesaikan task.

d. Menunggu Secara Sirkuler (Circular Wait) : Terdapat sekumpulan proses {P0, P1,

…, P0} yang menunggu sumber daya dimana P0 menunggu sumber daya yang dibawa P1,

P1 menunggu sumber daya yang dibawa P2, dan seterusnya, Pn–1 menunggu sumber daya
yang dibawa oleh Pn, dan Pn menunggu sumber daya yang dibawa P0.

Ketiga syarat pertama merupakan syarat perlu (necessary conditions) bagi

terjadinya deadlock. Keberadaan deadlock selalu berarti terpenuhi kondisi-kondisi
diatas, tak mungkin terjadi deadlock bila tidak ada ketiga kondisi itu. Deadlock terjadi
berarti terdapat ketiga kondisi itu, tetapi adanya ketiga kondisi itu belum berarti terjadi
deadlock.

Deadlock baru benar-benar terjadi bila syarat keempat terpenuhi. Kondisi

keempat merupakan keharusan bagi terjadinya peristiwa deadlock. Bila salah satu saja
dari kondisi tidak terpenuhi maka deadlock tidak terjadi.

15
2. Resource Allocation Graph

Deadlock dapat digambarkan lebih presisi dengan menggunakan graph berarah

yang disebut resource allocation graph. Graph terdiri dari himpunan titik V dan garis
E. Himpunan titik (vertex) V dibagi menjadi dua tipe yaitu himpunan proses yang
aktif pada sistem P = {P1, P2, ..., Pn} dan tipe sumber daya pada sistem R = {R1,
R2, ..., Rm}

Garis berarah dari proses Pi ke tipe sumber daya Rj dinotasikan dengan Pi  Rj

artinya proses Pi meminta satu anggota dari tipe sumber daya Rj dan sedang
menunggu sumber daya tersebut. Garis berarah dari tipe sumber daya Rj ke proses
Pi dinotasikan dengan Rj  Pi artinya satu anggota tipe sumber daya Rj dialokasikan
ke proses Pi. Garis berarah Pi  Rj disebut request edge dan garis berarah Rj  Pi
disebut assignment edge.

Notasi-notasi yang digunakan pada resource allocation graph adalah :

 Proses

 Tipe sumber daya dengan 4 anggota

 Pi meminta anggota dari Rj

Pi

Rj

 Pi membawa satu anggota Rj

P

Rj

16
 Contoh resource allocation graph dapat dilihat pada Gambar 6-1 dimana
keadaan sistem adalah sebagai berikut :

 Himpunan P, R dan E : 
o P = {P1, P2, P3}

o R = {R1, R2, R3, R4}

o E = {P1  R1, P2  R3, R1  P2, R2  P2, R2  P1, R3  P3}

 Anggota sumber daya :


o Satu anggota dari tipe sumber daya R1.
o Dua anggota dari tipe sumber daya R2.
o Satu anggota dari tipe sumber daya R3.
o Tiga anggota dari tipe sumber daya R4.

 Status proses :

o Proses P1 membawa satu anggota tipe sumber daya R2 dan menunggu satu
anggota tipe sumber daya R1.
o Proses P2 membawa satu anggota R1 dan R2 dan menunggu satu anggota tipe
sumber daya R3.
o Proses P3 membawa satu anggota R3.

Fakta dasar dari resource allocation graph menunjukkan bahwa :

 Apabila pada graph tidak terdapat siklus maka tidak ada proses dalam sistem yang
deadlock
 Apabila pada graph terdapat siklus sistem kemungkinan deadlock dengan
ketentuan: 
o Jika pada setiap tipe sumber daya hanya terdapat satu anggota maka
terjadideadlock

17
 o Jika pada setiap tipe sumber daya terdapat beberapa anggota maka
kemungkinan terjadi deadlock

Gambar 6-1 : Contoh Resource Allocation Graph

Untuk ilustrasi konsep diatas kita lihat kembali resource allocation graph
pada Gambar 6-1. Pada Gambar 6-1 tidak terdapat siklus, jadi tidak terjadi deadlock
pada sistem. Misalnya proses P3 meminta satu anggota dari tipe sumber daya R2.
Karena tidak tersedia anggota tipe sumber daya tersebut, request edge P3  R2
ditambahkan ke graph seperti pada Gambar 6-2. Pada kasus ini, terdapat dua siklus
pada sistem, yaitu :

P1 R1  P2  R3 P3  R2 P1

P2  R3 P3  R2 P2

Proses P1, P2 dan P3 terjadi deadlock. Proses P2 menunggu sumber daya R3 yang dibawa
proses P3. Proses P3 sebaliknya menunggu proses P1 atau P2 melepas sumber daya R2.
Proses P1 menunggu proses P2 melepas sumber daya R1.

18
 Gambar 6-2 : Resource allocation graph yang terjadi deadlock

Pada contoh resource allocation graph Gambar 6-3 terdapat siklus :

P1 R1  P3  R3 P1

Akan tetapi pada sistem tidak terjadi deadlock. Terlihat bahwa proses P4 kemungkinan
melepas tipe sumber daya R2. Sumber daya tersebut kemudian dapat dialokasikan untuk
P3 dan akan menghapus siklus.

Gambar 6-3 : Resource allocation graph yang tidak terjadi deadlock

19
 D. Metode Menangani Deadlock
Terdapat tiga metode untuk menangani permasalahan deadlock yaitu :
o Menggunakan protocol untuk menjamin bahwa sistem tidak pernah memasuki
status deadlock
o Mengijinkan sistem memasuki status deadlock dan kemudian memperbaikinya.
o Mengabaikan permasalahan dan seakan-akan deadlock tidak pernah terjadi pada
sistem. Model ini yang banyak digunakan pada sistem operasi termasuk UNIX.

E. Mencegah Deadlock

Metode ini berkaitan dengan pengkondisian sistem agar menghilangkan

kemungkinan terjadinya deadlock. Pencegahan merupakan solusi yang bersih
dipandang dari sudut tercegahnya deadlock. Metode ini sering menghasilkan utilisasi
sumber daya yang buruk. Pencegahan deadlock merupakan metode yang banyak
dipakai.

Untuk mencegah deadlock dilakukan dengan meniadakan salah satu dari syarat
perlu sebagai berikut :

 Mencegah Mutual Exclusion

Mutual exclusion benar-benar tak dapat dihindari. Hal ini dikarenakan tidak ada
sumber daya yang dapat digunakan bersama-sama, jadi sistem harus membawa
sumber daya yang tidak dapat digunakan bersama-sama.

 Mencegah Hold and Wait

Untuk mencegah hold and wait, sistem harus menjamin bila suatu proses
meminta sumber daya, maka proses tersebut tidak sedang memegang sumber
daya yang lain. Proses harus meminta dan dialokasikan semua sumber daya yang
diperlukan sebelum proses memulai eksekusi atau mengijinkan proses meminta
sumber daya hanya jika proses tidak membawa sumber daya lain. Model ini
mempunyai utilitas sumber daya yang rendah dan kemungkinan terjadi
starvation jika proses membutuhkan sumber daya yang popular sehingga terjadi

20
 keadaan menunggu yang tidak terbatas karena setidaknya satu dari sumber daya
yang dibutuhkannya dialokasikan untuk proses yang lain.

 Mencegah Non Preemption

Peniadaan non preemption mencegah proses-proses lain harus menunggu. Seluruh

proses menjadi preemption, sehingga tidak ada tunggu menunggu. Cara mencegah
kondisi non preemption :

o Jika suatu proses yang membawa beberapa sumber daya meminta sumber daya
lain yang tidak dapat segera dipenuhi untuk dialokasikan pada proses tersebut,
maka semua sumber daya yang sedang dibawa proses tersebut harus
dibebaskan.

o Proses yang sedang dalam keadaan menunggu, sumber daya yang dibawanya
ditunda dan ditambahkan pada daftar sumber daya.

o Proses akan di restart hanya jika dapat memperoleh sumber daya yang lama dan
sumber daya baru yang diminta.

 Mencegah Kondisi Menunggu Sirkular

Sistem mempunyai total permintaan global untuk semua tipe sumber daya. Proses
dapat meminta proses kapanpun menginginkan, tapi permintaan harus dibuat terurut
secara numerik. Setiap proses yang membutuhkan sumber daya dan memintanya
maka nomor urut akan dinaikkan. Cara ini tidak akan menimbulkan siklus. Masalah
yang timbul adalah tidak ada cara pengurutan nomor sumber daya yang memuaskan
semua pihak.

F. Menghindari Deadlock
Metode alternatif untuk menghindari deadlock adalah digunakan informasi tambahan
tentang bagaimana sumber daya diminta. Misalnya pada sistem dengan satu tape drive dan
satu printer, proses P pertama meminta tape drive dan kemudian printer sebelum
melepaskan kedua sumber daya tersebut. Sebaliknya proses Q pertama meminta printer
kemudian tape drive. Dengan mengetahui urutan permintaan dan pelepasan sumber daya
untuk setiap proses, dapat diputuskan bahwa untuk setiap permintaan apakah proses
harus menunggu atau tidak. Setiap permintaan ke sistem harus dipertimbangkan apakah

21
 sumber daya tersedia, sumber daya sedang dialokasikan untuk proses dan permintaan
kemudian serta pelepasan oleh proses untuk menentukan apakah permintaan dapat
dipenuhi atau harus menunggu untuk menghindari deadlock.

Model yang sederhana dan sangat penting dibutuhkan adalah setiap proses
menentukan jumlah maksimum sumber daya dari setiap tipe yang mungkin diperlukan.
Algoritma deadlock avoidance secara dinamis memeriksa status sumber daya yang
dialokasikan untuk menjamin tidak pernah terjadi kondisi menunggu sirkular. Status
alokasi sumber daya ditentukan oleh jumlah sumber daya yang tersedia dan yang
dialokasikan dan maksimum permintaan oleh proses-proses.

Untuk penghindaran deadlock diperlukan pengertian mengenai state aman (safe

state) dan state tak aman (unsafe state).

1. State Aman (Safe State)

Ketika suatu proses meminta sumber daya yang tersedia, sistem harus menentukan
apakah alokasi sumber daya pada proses mengakibatkan sistem dalam state aman. Sistem
dikatakan dalam state aman jika sistem dapat mengalokasikan sumber daya untuk setiap
proses secara berurutan dan menghindari deadlock. Urutan proses <P1, P2, …, Pn> aman

jika untuk setiap Pi, sumber daya yang masih diminta Pi masih memenuhi sumber daya
yang tersedia dan sumber daya yang dibawa oleh setiap Pj, dimana j < i. Jika sumber daya

yang diperlukan Pi tidak dapat segera disediakan, maka Pi dapat menunggu sampai semua

Pj selesai. Ketika Pj selesai, Pi dapan memperoleh sumber daya yang diperlukan,

mengeksekusi, mengembalikan sumber daya yang dialokasikan dan terminasi. Ketika Pi

selesai, Pi+1 dapat memperoleh sumber daya yang diperlukan dan seterusnya.

Jika sistem dalam state aman maka tidak terjadi deadlock, sedangkan jika sistem dalam
state tidak aman (unsafe state) maka kemungkinan terjadi deadlock seperti Gambar 6-4.
Metode menghindari deadlock menjamin bahwa sistem tidak pernah memasuki state tidak
aman.

22
 Gambar 6-4 : Ruang state aman, tak aman dan deadlock

Untuk menggambarkan sistem dapat berpindah dari state aman ke state tidak
aman dapat dilihat ilustrasi berikut ini. Misalnya sistem mempunyai 12 magnetic
tape drive dan 3 proses P0, P1 dan P2. Proses P0 membutuhkan 10 tape drive,

proses P1 membutuhkan 4 dan proses P2 membutuhkan 9 tape drive. Misalnya pada

waktu t0, proses P0 membawa 5 tape drive, P1 membawa 2 dan P2 membawa 2
tape drive sehingga terdapat 3 tape drive yang tidak digunakan.

Kebutuhan Maksimum Kebutuhan Sekarang

P0 10 5

P1 4 2

P2 9 2

Pada waktu t0, sistem dalam state aman. Urutan < P1, P0, P2> memenuhi kondisi
aman karena P1 dapat segera dialokasikan semua tape drive dan kemudian
mengembalikan semua tape drive sehingga sistem tersedia 5 tape drive. Kemudian

23
 P0 dapat memperoleh semua tape drive dan mengembalikan semua sehingga sistem
tersedia 10 tape drive dan terakhir proses P2 dapat memperoleh semua tape drive
dan mengembalikan semua tape drive sehingga system tersedia 12 tape drive.

Sistem dapat berubah dari state aman ke state tidak aman. Misalnya
pada waktu t1, proses P2 meminta tambahan alokasi 1 tape drive. Sistem
menjadi tidak aman. Pada saat ini, hanya proses P1 yang mendapatkan semua
tape drive dan kemudian mengembalikan semua tape drive sehingga hanya
tersedia 4 tape drive. Karena proses P0 sudah dialokasikan 5 tape drive tetapi
membutuhkan maksimum 10 tape drive sehingga meminta 5 tape drive lagi.
Karena tidak tersedia, proses P0 harus menunggu demikian juga P2 sehingga
system menjadi deadlock.

2. Algoritma Resource Allocation Graph

Untuk menghindari deadlock pada sistem yang hanya mempunyai satu

anggota untuk setiap tipe sumber daya, dapat digunakan algoritma resource
allocation graph. Claim edge Pi  Rj menandakan bahwa proses Pi mungkin
meminta sumber daya Rj yang direpresentasikan dengan garis putus-putus. Claim
edge akan berubah ke request edge bila proses meminta sumber daya. Bila sumber
daya dibebaskan oleh proses, assignment edge diubah ke claim edge. Sumber daya
sebelumnya harus diklaim pada sistem. Sehingga sebelum proses Pi mulai
dieksekusi, semua claim edge harus muncul pada resource allocation graph.

Misalnya proses Pi meminta sumber daya Rj. Permintaan dapat

dipenuhi hanya jika mengubah request edge Pi  Rj ke assignment edge Rj 
Pi tidak menyebabkan siklus pada graph. Jika tidak terdapat siklus, maka
alokasi sumber daya menyebabkan sistem dalam state aman. Jika terjadi siklus,
maka alokasi akan membawa sistem pada state tak aman. Sehingga proses Pi
harus menunggu permintaan dipenuhi.

24
 Gambar 6-5 : Menghindari deadlock dengan algoritma resouce allocation

graph

Untuk menggambarkan algoritma ini, perhatikan resource allocation

graph Gambar 6-5. Misalnya P2 meminta R2. Meskipun R2 bebas, tetapi tidak dapat
dialokasikan untuk P2, karena akan menyebabkan siklus pada graph (Gambar 6-
6). Siklus menandakan sistem dalam state tak aman. Jika P1 meminta R2 dan P2
meminta R1, maka terjadi deadlock.

Gambar 6-6 : State tak aman pada resouce allocation graph

25
 3. Algoritma Banker

Algoritma resource allocation graph tidak dapat diaplikasikan pada sistem

yang mempunyai beberapa anggota pada setiap tipe sumber daya. Setiap proses sebelum
dieksekusi harus menentukan jumlah sumber daya maksimum yang dibutuhkan. Jika
suatu proses meminta sumber daya kemungkinan proses harus menunggu. Jika suatu
proses mendapatkan semua sumber daya maka proses harus mengembalikan semua
sumber daya dalam jangka waktu tertentu.

Struktur data yang digunakan untuk mengimplementasikan algoritma

Banker akan menentukan state dari sumber daya yang dialokasikan oleh sistem.
Misalnya n = jumlah proses dan m = jumlah tipe resource. Struktur data yang
diperlukan :

 Available : Vektor panjang m. Jika Available[j] = k, terdapat k anggota tipe

sumber daya Rj yang tersedia.


 Max : matrik n x m. Jika Max[i, j] = k, maka proses Pi meminta paling banyak

k anggota tipe resource Rj.

 Allocation : matrik n x m. Jika Allocation[i, j] = k maka Pi sedang

dialokasikan k anggota tipe resource Rj.


 Need : matrik n x m. Jika Need[i, j] = k, maka Pi membutuhkan k anggota tipe

resource Rj untuk menyelesaikan task. Need[i, j] = Max[i, j] – Allocation[i, j].


Beberapa notasi yang perlu diketahui adalah misalnya X dan Y adalah vektordengan
panjang n. X  Y jika dan hanya jika X[i]  Y[i] untuksemua i = 1, 2, .., n.Sebagai
contoh jika X = (1, 7, 3, 2) dan Y = (0, 3, 2, 1) maka Y  X.

26
 a. Algoritma Safety
Algoritma ini untuk menentukan apakah sistem berada dalam state aman atau tidak.

1. Work dan Finish adalah vector dengan panjang m dan n. Inisialisasi : Work
= Available dan Finish[i] = false untuk i = 1,3, …, n.
2. Cari i yang memenuhi kondisi berikut :
(a) Finish [i] = false
(b) Needi  Work
3. Work = Work + Allocationi Finish[i] = true Kembali ke langkah 2.
4. Jika Finish [i] == true untuk semua i, maka sistem dalam state aman.

b. Algoritma Resouce Request

Requesti adalah vector permintaan untuk proses Pi. Jika Requesti[j] = k, maka proses
Pi menginginkan k anggota tipe sumber daya Rj. Jika permintaan untuk sumber daya
dilakukan oleh proses Pi berikut ini algoritmanya.
Request = request vector for process Pi. If Requesti [j] = k then process Pi wants k
instances of resource type Rj.
1. Jika Requesti  Needi ke langkah 2. Selain itu, terjadi kondisi error karena proses
melebihi maksimum klaim.

2. Jika Requesti  Available, ke langkah 3. Selain itu Pi harus menunggu

karena sumber daya tidak tersedia.

3. Alokasikan sumber daya untuk Pi dengan modifikasi state

Jika hasil state alokasi sumber daya adalah aman, maka sumber daya dialokasikan
ke Pi, sebaliknya jika tidak aman, Pi harus menunggu dan state alokasi sumber daya
yang lama disimpan kembali.

27
c. Contoh Penggunaan Algoritma Banker
Diketahui sistem terdapat 5 proses yaitu P0 sampai P4, 3 tipe sumber daya yaitu A (10
anggota), B (5 anggota) dan C (7 anggota). Perhatikan gambaran sistem pada waktu
T0.

Allocation Max Available

ABC ABC ABC

P0 010 753 332

P1 200 322

P2 302 902

P3 211 222

P4 002 433

Isi matrik Need didefinisikan dengan Max – Allocation.

Need
ABC
P0 7 4 3
P1 1 2 2
P2 6 0 0
P3 0 1 1
P4 4 3 1

Sistem dalam keadaan state aman dengan urutan < P1, P3, P4, P2, P0> yang

memenuhi kriteria algoritma safety.

28
 Misalnya proses P1 meminta tambahan anggota tipe sumber daya A dan
dua anggota tipe sumber daya C sehingga Request1 = (1, 0, 2). Untuk menentukan
apakah permintaan dapat segera dipenuhi, pertama harus diperiksa apakah
Request1  Available ((1, 0, 2)  (3, 3, 2)) ternyata benar. Maka akan diperoleh
state baru berikut :

Allocation Need Available

ABC ABC ABC

P0 010 743 230

P1 302 020

P2 301 600

P3 211 011

P4 002 431

Kemudian harus ditentukan apakah sistem berada dalam state aman.

Setelah mengeksekusi algoritma safety ternyata urutan <P1, P3, P4, P0, P2>
memenuhi criteria safety.

Setelah sistem berada pada state doatas, permintaan (3, 3, 0) oleh P4 tidak
dapat dipenuhi karena sumber daya tidak tersedia. Permintaan (0, 2, 0) oleh P1
juga tidak dapat dipenuhi karena meskipun sumber daya tersedia, state hasil tak
aman.

29
G. Mendeteksi Deadlock
Jika sistem tidak menyediakan algoritma mencegah deadlock dan menghindari
deadlock, maka terjadi deadlock. Pada lingkungan ini sistem harus menyediakan :
 Algoritma yang menguji state sistem untuk menentukan apakah deadlock telah
terjadi.
 Algoritma untuk memperbaiki dari deadlock.
1. Satu Anggota untuk Setiap Tipe Sumber Daya
Jika semua sumber daya hanya mempunyai satu anggota, kita dapat
menentukan algoritma mendeteksi deadlock menggunakan bentuk resource
allocation graph yang disebut wait-for graph.

Garis dari Pi → Pj pada wait-for graph menandakan bahwa proses Pi

menunggu Pj melepaskan sumber daya yang dibutuhkan Pi. Garis Pi → Pj terdapat
pada wait-for graph jika dan anya jika resource allocation graph berisi dua garis
Pi → Rq dan Rq → Pj untuk beberapa sumber daya Rq seperti Gambar 6-7.

Secara periodik sistem menggunakan algoritma yang mencari siklus pada

graph. Algoritma untuk mendeteksi siklus pada graph membutuhkan operasi n2
dimana n adalah jumlah titik pada graph.

Gambar 6-7 : (a) Resource allocation graph (b) Wait-for graph

2. Beberapa Anggota untuk Setiap Tipe Sumber Daya

30
 Untuk Tipe sumber daya yang mempunyai beberapa anggota digunakan
algoritma yang sejenis dengan algoritma Banker dengan struktur daya seperti di
bawah ini :

 Available : vector panjang m menandakan jumlah sumber daya yang tersedia

untuk setiap tipe sumber daya.
 Allocation : matrik n x m yang mendefinisikan jumlah sumber daya untuk
setiap tipe sumber daya yang sedang dialokasikan untuk setiap proses.
 Request : matrik n x m yang mendefinisikan permintaan setiap proses. Jika
Request [I, j] = k, maka proses Pi meminta k anggota tipe sumber daya Rj.

Algoritma mendeteksi deadlock mempunyai urutan berikut :

1. Work dan Finish adalah vektor panjang m dan n. Inisialisasi Work = Available.
Untuk i = 1, 2, …, n, jika Allocationi ¹ 0, maka Finish[i] = false; sebaliknya
Finish[i] = true.
2. Cari indeks i yang memenuhi kondisi berikut :
(a) Finish[i] == false
(b) Requesti £ Work
3. Work = Work + Allocationi Finish[i] = true
Ke langkah 2.
4. Jika Finish[i] == false, untuk beberapa i, 1 £ i £ n, maka sistem berada pada state
deadlock state. Jika Finish[i] == false, maka Pi deadlock

Algoritma ini memerlukan operasi O(m x n2) untuk mendeteksi apakah sistem
berada pada state deadlock.

Untuk menggambarkan algoritma deteksi, misalnya sistem terdapat 5 proses

P0 sampai P4 dan 3 tipe sumber daya A, B dan C. Tipe sumber daya A mempunyai 7
anggota, tipe sumber daya B mempunyai 2 anggota dan tipe sumber daya C
mempunyai 6 anggota. Pada waktu T0, state sumber daya yang dialokasikan adalah :

31
 Allocation Request Available
ABC ABC ABC
P0 010 000 000
P1 200 202
P2 303 000
P3 211 100
P4 002 002

Sistem tidak berada pada state deadlock karena urutan <P0, P2, P3, P1, P4>
menghasilkan Finish[i] = true untuk semua i.

Misalnya saat ini proses P2 membutuhkan tambahan satu anggota tipe sumber
daya C. Matrik Request dimodifikasi sebagai berikut :

Request

 ABC
P0 000
P1 202
P2 001
P3 100
P4 002
Sistem sekarang berada pada state deadlock. Meskipun proses P0 dapat membawa
sumber daya, jumlah sumber daya yang tersedia tidak dapat memenuhi permintaan proses
lain. Sehingga terjadi deadlock pada proses P1, P2, P3 dan P4.

3. Penggunaan Algoritma Deteksi

Untuk menjawab kapan dan berapa sering menggunakan algoritma deteksi,
hal ini tergantung pada :
1. Seberapa sering terjadi deadlock.
2. Berapa proses yang perlu dilakukan roll back.

Jika algoritma deteksi digunakan, terdapat beberapa siklus pada graph, hal
ini tidak dapat mengetahui berapa proses yang deadlock yang menyebabkan
deadlock.
32
H. Perbaikan dari Deadlock
Terdapat dua pilihan untuk membebaskan deadlock. Satu solusi sederhana adalah
dengan menghentikan satu atau beberapa proses untuk membebaskan kondisi menunggu
sirkular. Pilihan kedua adalah menunda beberapa sumber daya dari satu atau lebih proses
yang deadlock.
1. Terminasi Proses
Untuk memperbaiki deadlock dengan terminasi proses, dapat diguankan salah satu dari
dua metode di bawah ini :
 Menghentikan (abort) semua proses yang deadlock
 Menghentikan satu proses setiap waktu sampai siklus deadlock hilang.
Untuk menentukan urutan proses yang harus dihentikan ada beberapa faktor yang
harus diperhatikan :
 Prioritas proses.
 Berapa lama proses dijalankan dan berapa lama lagi selesai.
 Sumber daya yang digunakan proses.
 Sumber daya proses yang diperlukan untuk menyelesaikan task.
 Berapa proses yang perlu diterminasi.
 Apakah proses interaktif atau batch.
2. Menunda Sumber Daya
Untuk menghilangkan deadlock dengan menunda sumber daya, sumber daya
dari proses harus ditunda dan memberikan sumber daya tersebut ke proses lain
sampai siklus deadlock hilang.
Jika penundaan dibutuhkan untuk menghilangkan deadlock, terdapat tiga hal
yang perlu diperhatikan :
 Pilihlah korban (sumber daya) yang mempunyai biaya minimal.
 Lakukan rollback yaitu memulai kembali (restart) proses pada state yang aman.
 Harus dijamin starvation tidak akan terjadi karena kemungkinan beberapa proses
selalu terpilih sebagai korban termasuk jumlah rollback sebagai faktor biaya.

I. Metode Kombinasi Menangani Deadlock

33
 Untuk menangani deadlock dilakukan kombinasi dari tiga algoritma dasar yaitu
mencegah deadlock, menghindari deadlock dan mendeteksi deadlock. Kombinasi
ketiga algoritma ini memungkinkan penggunaan yang optimal untuk setiap sumber
daya pada sistem.

34
 BAB III

PENUTUP

3.1 Kesimpulan
Sinkronisasi adalah akses bebarengan untuk berbagi dua bersama dapat
mengakibatkan inkosistensi data. Pemeliharaan konsistensi data memerlukan mekanisme
untuk memastikan eksekusi dari proses kerjasama.
Tujuan dari sinkronisasi itu sendiri ialah untuk menghindari terjadinya inkonsitensi
data karena pengaksesan oleh beberapa proses yang berbeda serta untuk mengatur urutan
jalannya proses-proses sehingga dapat berjalan dengan baik dan sesuai apa yang di
harapkan.
Deadlock adalah keadaan dimana 2 atau lebih proses saling menunggu meminta
resources untuk waktu yang tidak terbatas lamanya. Analoginya seperti pada kondisi jalan
raya dimana terjadi kemacetan parah. Deadlock adalah efek samping dari sinkronisasi,
dimana satu variabel digunakan oleh 2 proses. Sinkronisasi dan Deadlock dapat
ditanggulangi dengan cara cara tertentu dan dapat dicegah dalam proses proses tertentu.

35
 DAFTAR PUSTAKA

Anggraini. (2017, Mei 5). Masalah Klasik Sinkronisasi. Diambil kembali dari stessedout:
http://stessedout.blogspot.com/2017/05/masalah-klasik-sinkronisasi.html

Gonieswara, M. (2017, October 20). Sistem Operasi: Pengertian Deadlock. Diambil kembali dari
majalahpendidikan: https://majalahpendidikan.com/sistem-operasi-pengertian-deadlock/

Yasri. (2015, September 16). Pengertian Sinkronisasi Sistem Operasi Lengkap. Diambil kembali
dari genggaminternet: http://genggaminternet.com/pengertian-sinkronisasi-sistem-
operasi-lengkap/

36