Tugas Mata Kuliah

Pengantar Sistem Operasi

Sinkronisasi
Disusun Oleh :
Niken Dwi Trisnaningati (5214100091)
Yoga Setya Prayudha (5214100101)
Risha Zahra Aditya (5214100114)

Adham Adihatmojo (5214100122)

Aditya Septa Setya Budi (5214100126)

JURUSAN SISTEM INFORMASI - FTIF

INSTITUT TEKNOLOGI SEPULUH NOPEMBER
SURABAYA
2015

1. Producer /Consumer problem

Bounded-Buffer (Producer-Consumer) Problem
Produsen menghasilkan barang dan konsumen yang akan menggunakannya. Ada
beberapa batasan yang harus dipenuhi, antara lain :

Barang yang dihasilkan oleh produsen terbatas

Barang yang dipakai konsumen terbatas
Konsumen hanya boleh menggunakan barang yang dimaksud setelah produsen
menghasilkan barang dalam jumlah tertentu
Produsen hanya boleh memproduksi barang jika konsumen sudah kehabisan barang

Untuk penyelesaian permasalahan bounded buffer menggunakan semaphore

menggunakan variabel umum berikut : semaphore full, empty, mutex; Inisialisasi untuk
variable di atas, full = 0, empty = n, mutex = 1. Struktur program untuk produsen adalah
do {

menghasilkan item pada nextp

wait(empty);
wait(mutex);

menambah nextp ke buffer

signal(mutex);
signal(full);
} while (1);

Sedangkan struktur program untuk konsumen adalah

do {

wait(full)
wait(mutex);

mengambil item dari buffer ke nextc

signal(mutex);
signal(empty);

menggunakan item pada nextc

} while (1);
Reader and Writer Problem
Terdapat dua variasi pada masalah ini, yaitu :
a. seorang reader tidak perlu menuggu reader lain untuk selesai hanya karena ada writer
menunggu (reader memiliki prioritas lebih tinggi disbanding dengan writer)
b. Jika ada writer yang sedang menunggu, maka tidak boleh ada reader lain yang bekerja
(writer memiliki prioritas yang lebih tinggi)
Jika terdapat writer dalam critical section dan terdapat n reader yang menunggu, maka
satu reader akan antri di wrt dan n-1 reader akan antri di mutex. Jika writer mengeksekusi
signal(wrt), maka dapat disimpulkan bahwa eksekusi adalah menunggu reader atau
menunggu satu writer.
Sumber : http://journal.amikom.ac.id/index.php/KIDA/article/view/3352
2. The critical Section Problem
Suatu sistem terdiri dari n proses dimana semuanya berkompetisi menggunakan
data yang digunakan bersama-sama. Masing-masing proses mempunyai sebuah kode
segmen yang disebut dengan critical section, dimana proses memungkinkan untuk
mengubah variabel umum, mengubah sebuah tabel, menulis file dan lain
sebagainya. Gambaran penting dari sistem adalah, ketika sebuah proses dijalankan di
dalam critical section, tidak ada proses lain yang diijinkan untuk menjalankan critical

section-nya. Sehingga eksekusi dari critical section oleh proses-proses tersebut berlaku
eksklusif (mutually exclusive). Permasalahan critical section digunakan untuk mendesain
sebuah protokol dimana proses-proses dapat bekerja sama. Masing-masing proses
harus
meminta ijin untuk memasuki critical section-nya. Daerah kode
yang mengimplementasikan perintah ini disebut daerah entry. Critical section biasanya
diikuti oleh daerah exit. Kode pengingat terletak di daerah remainder. Sebuah solusi dari
permasalahan critical section harus memenuhi 3 syarat sebagai berikut :
1. Mutual Exclusion. Apabila proses Pi menjalankan critical section-nya, maka tidak
ada proses lain yang dapat menjalankan critical section.
2. Progress. Apabila tidak ada proses yang menjalankan critical section-nya dan terdapat
beberapa proses yang akan memasuki critical section-nya, maka hanya proses-proses
itu yang tidak diproses di dalam daerah pengingat (remainder) dapat ikut berpartisipasi
di dalam keputusan proses mana yang akan memasuki critical section selanjutnya, dan
pemilihan ini tidak dapat ditunda tiba-tiba.
3. Bounded Waiting. Terdapat batasan jumlah waktu yang diijinkan oleh proses lain
untuk memasuki critical section setelah sebuah proses membuat permintaan untuk
memasuki critical section-nya dan sebelum permintaan dikabulkan.
Critical Section mempunyai beberapa kode :
1. Entry Section : kode yang digunakan untuk masuk ke dalam critical section.
2. Critical Section : Kode di mana hanya ada satu proses yang dapat dieksekusi pada satu
waktu.
3. Exit Section: akhir dari critical section, mengizinkan proses lain.
4. Remainder Section : kode istirahat setelah masuk ke critical section.

Asumsi bahwa masing-masing proses dijalankan pada kecepatan bukan nol

(nonzero). Akan tetapi tidak ada asumsi mengenai kecepatan relatif dari proses ke n.
Pemecahan masalah critical section tidak mengandalkan semua asumsi tentang instruksi
hardware atau jumlah prosessor dari hardware yang mendukung. Akan tetapi, diasumsikan
bahwa instruksi dasar bahasa mesin (instruksi primitif, misalnya load, store dan test)
dijalankan secara otomatis. Sehingga apabila dua instruksi dijalankan

Sumber : https://ayuewiejayantie.wordpress.com/sinkronisasi-proses/
http://arbi-wiranata-fst13.web.unair.ac.id/artikel_detail-103306-KuliahSinkronisasi%20pada%20Sistem%20Operasi.html
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.
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
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.
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.
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.
Macam macam semaphore :
1. Binary semaphore
Binary semaphore adalah semafor yang bernilai hanya 1 dan 0.
2. Counting semaphore
Counting semaphore adalah semafor yang dapat bernilai 1 dan 0 dan nilai integer yang
lainnya.
Prinsip semaphore :

Dua proses atau lebih dapat bekerja sama dengan menggunakan penanda-penanda
sederhana
Proses dipaksa berhenti sampai proses memperoleh penanda tertentu
Variabel khusus untuk penandaan ini disebut semaphore

Fungsi Semaphore Seperti telah disebutkan sebelumnya, semaphore berfungsi untuk

menangani masalah sinkronisasi secara umum, yaitu:

1) Mutual Exclusion. Sesuai dengan prinsip mutual exclusion, jika suatu thread sedang
berada dalam critical section-nya, thread lain harus menunggu thread tersebut keluar
dari critical section-nya sebelum dapat memasuki critical section-nya sendiri. Di
sinilah semaphore digunakan, thread yang akan memasuki critical section-nya akan
memanggil fungsi kunci terlebih dahulu. Jika tidak ada thread lain yang sedang berada
dalam critical section, thread ini akan memasuki critical section-nya. Jika terdapat
thread lain yang sedang berada dalam critical section-nya, thread ini harus
menunggu.Setelah thread keluar dari critical section-nya, thread tersebut akan
memanggil fungsi buka sehingga sem_value akan naik menjadi lebih dari 0, dan satu
(dari beberapa) thread yang sedang menunggu akan mendapatkan giliran untuk
memasuki critical section-nya.
Sebagai contoh, misalnya terdapat dua buah thread yang sedang berjalan bersamaan:
thread A:
count = count + 1;

thread B:
count = count + 1;

Thread A dan B mengakses variabel yang sama, yaitu count sehingga thread A dan
B harus berjalan satu-satu. Untuk itu digunakan semaphore mutex yang berupa binary
semaphore dengan nilai awal 1.
thread A:

thread B:

kunci(mutex);

kunci(mutex);

count = count + 1;

count = count + 1;

buka(mutex);

buka(mutex);

Thread manapun yang mengeksekusi kunci terlebih dahulu akan jalan terus,
sedangkan thread yang tiba belakangan akan menunggu sampai thread yang sudah
berjalan terlebih dahulu mengeksekusi buka, setelah itu kedua thread berjalan lagi
dengan normal.
2) Resource Controller. Bayangkan sebuah restoran yang setiap malamnya ramai
dikunjungi pelanggan. Kapasitas restoran terbatas, tetapi pemilik restoran memiliki
kebijakan bahwa semua pengunjung yang datang akan mendapatkan kesempatan untuk
makan, dengan konsekuensi yaitu pelanggan harus sabar menunggu gilirannya. Oleh
karena itu, dikerahkanlah pegawai restoran untuk menahan tamu di luar jika restoran
penuh lalu mempersilahkan tamu masuk jika tempat telah tersedia.Dari analogi di atas,
pelanggan adalah thread, kapasitas restoran adalah resource, dan pegawai restoran
adalah semaphore. Semaphore menyimpan banyaknya resource yang tersedia. Saat
thread ingin memakai resource ia akan memanggil fungsi kunci. Jika resource masih
tersedia, thread bisa langsung menggunakannya, sebaliknya jika semua resource sedang
dipakai, thread tersebut harus menunggu. Setelah resource selesai dipakai thread akan
memanggil fungsi buka sehingga resource yang bebas bertambah.

Contohnya dapat kita lihat pada kasus berikut: Terdapat tiga buah thread yang berjalan
bersamaan. Resource yang tersedia hanya cukup untuk dua buah thread.
thread A:

thread B:

//critical section

thread C:

//critical section //critical section

Tentu saja harus diatur agar pada suatu saat hanya ada dua buah thread yang berada
pada critical section-nya. Hal ini dilakukan dengan menggunakan semaphore multiplex
yaitu sebuah counting semaphore dengan nilai awal sama dengan jumlah resource yang
tersedia yaitu dua.
thread A:

thread B:

kunci(multiplex);

thread C:

kunci(multiplex);

kunci(multiplex);

//critical section //critical section //critical section

buka(multiplex);

buka(multiplex);

buka(multiplex);

Jika dua buah thread sedang berada dalam critical section, thread berikutnya yang akan
memasuki critical section harus menunggu kedua thread tersebut selesai untuk dapat
memasuki critical section-nya.
3) Sinkronisasi Antar-Proses. Ada kalanya suatu thread memerlukan resource yang
dihasilkan oleh thread lainnya. Oleh karena itu dibutuhkan suatu mekanisme untuk
mengatur urutan eksekusi thread. Mekanisme ini dilakukan dengan memanfaatkan
semaphore.
Sebagai contoh, misalnya terdapat dua buah thread yang sedang berjalan bersamaan:
thread A:
count = count + 1;

thread B:
count = count * 2;

Nilai awal dari variabel count adalah 5, nilai akhir yang diinginkan adalah 12, oleh
karena itu thread A harus dieksekusi sebelum thread B. Agar hal ini dapat terjadi
dibutuhkan suatu semaphore mutex yang merupakan sebuah binary semaphore dengan
nilai awal 0.
thread A:
count = count + 1;
buka(mutex);

thread B:
kunci(mutex);
count = count * 2;

Thread B akan menunggu sampai eksekusi thread A selesai sebelum melanjutkan. Jika
kita cermati fungsi kunci, thread akan terus berada dalam waiting loop sampai
sem_value naik lebih dari 0. Padahal, di dalam loop tersebut thread tidak melakukan
tugas apa-apa. Inilah yang disebut dengan busy waiting (semaphore jenis ini disebut
dengan semaphore spinlock). Hal ini tentu saja akan berakibat buruk terhadap kinerja
CPU, karena loop tersebut membutuhkan CPU cycle, sementara loop tersebut tidak
menghasilkan apa-apa, jadi sama saja dengan menyia-nyiakan CPU cycle.Untuk
mengatasi hal ini, dibuatlah modifikasi dari semaphore, yaitu dengan menambahkan
waitingqueue pada masing-masing semaphore. Tujuannya adalah agar thread yang
harus menunggu dipindahkan ke waiting queue dan kegiatannya dihentikan
sementara.Ketika thread keluar dari critical section-nya, thread tersebut akan
memanggil fungsi buka yang akan mengeluarkan satu (dari beberapa) thread yang
berada dalam waiting queue lalu membangunkannya untuk kemudian memasuki critical
section-nya.
Keuntungan menggunakan semaphore:
1.
Dari segi programming, penanganan masalah sinkronisasi dengan semaphore
umumnya rapi dan teratur, sehingga mudah untuk dibuktikan kebenarannya
2.
Semaphore diimplementasikan dalam hard code sehingga penggunaannya
bersifat portabel
Sumber : https://ayuewiejayantie.wordpress.com/sinkronisasi-proses/
http://tuanx.blogspot.com/2011/06/sistem-operasi-semaphore.html
https://rizaarifudin.wordpress.com/2011/02/15/semaphore/
4. Producer/consumer semaphore solution
A Semaphore Solution to the Producer-Consumer Problem
Ini adalah sebuah gambaran dari solusi terhadap masalah klasik produsen-konsumen (boundedbuffer) dengan menggunakan Semaphore.
KONSEP: Produsen menghasilkan barang yang akan disimpan dalam buffer. Konsumen
menghapus dan mengkonsumsi barang-barang yang telah disimpan. Mutual exclusion (Mutex)
harus ditetapkan pada buffer itu sendiri. Selain itu, produsen dapat menyimpan hanya bila ada slot
yang kosong, dan konsumen dapat menghapus hanya ketika ada slot penuh.
Saat tiga Semaphore digunakan kontrol semaphore mutex biner akan mengakses buffer itu sendiri.
Penghitungan semaphore kosong melacak slot kosong, dan semaphore penghitungan penuh
melacak slot penuh.
Dalam contoh ini, buffer yang diimplementasikan sebagai array ukuran MAX diperlakukan
sebagai lingkaran (cincin) penyangga. Variabel masuk dan keluar memberikan indeks posisi

berikutnya untuk menempatkan dan mengambil. Total variabel menunjukan jumlah item dalam
buffer.
INITIALIZATION:
shared
shared
shared
shared
shared

binary semaphore mutex = 1;

counting semaphore empty = MAX;
counting semaphore full = 0;
anytype buffer[MAX];
int in, out, count;

PRODUCER :
anytype item;
repeat {
/* produce something */
item = produce();
/* wait for an empty space */
P(empty);
/* store the item */
P(mutex);
buffer[in] = item;
in = in + 1 mod MAX;
count = count + 1;
V(mutex);
/* report the new full slot */
V(full);
} until done;
CONSUMER:
anytype item;
repeat {
/* wait for a stored item */
P(full);
/* remove the item */

P(mutex);
item = buffer[out];
out = out + 1 mod MAX;
count = count - 1;
V(mutex);
/* report the new empty slot */
V(empty);
/* consume it */
consume(item);
} until done;
Sumber : http://www.csee.wvu.edu/~jdm/classes/cs550/notes/tech/mutex/pc-sem.html
5. Producer/consumer monitor solution
A Monitor Solution to the Producer-Consumer Problem
Ini adalah sebuah gambaran dari solusi untuk klasik produsen-konsumen (dibatasi-buffer)
masalah dengan menggunakan monitor.
KONSEP: Produsen menghasilkan barang yang akan disimpan dalam buffer. Konsumen
menghapus dan mengkonsumsi barang-barang yang telah disimpan. Mutual exclusion harus
ditegakkan pada buffer itu sendiri. Selain itu, produsen dapat menyimpan hanya bila ada slot
yang kosong, dan konsumen dapat menghapus hanya ketika ada slot penuh.
Buffer dan variabel kontrol diringkas oleh monitor. Monitor menyediakan prosedur untuk
menempatkan item dalam buffer dan untuk mengambil item dari buffer. Monitor mencakup dua
variabel kondisi: slot_free mewakili kondisi yang ada ruang untuk item, dan item yang hadir
mewakili kondisi bahwa setidaknya satu item hadir dalam buffer.
MONITOR:
DATA:
condition slot_free, item_present;
anytype buffer[MAX];
int in, out, count;
INITIALIZATION:
in = 0;
out = 0;
count = 0;

PROCEDURES:
void put_in_buffer(anytype item) {
/* if no space is available, wait for one */
if (count >= MAX)slot_free.wait;
/* store the item */
buffer[in] = item;
in = in + 1 mod n;
count = count + 1;
/* signal that the item is present */
item_present.signal;
}
anytype get_from_buffer(void) {
anytype item;
/* if no items are present, wait for one */
if (count <= 0) item_present.wait;
/* get the next item */
item = buffer[out];
out = out + 1 mod n;
count = count - 1;
/* announce that a space is free */
slot_free.signal;
/* return the item */
return(item);
}
PRODUCER :
repeat {
/* produce an item */
item = produce();
/* put it in the buffer */
put_in_buffer(item);
} until done;

CONSUMER:
repeat {
/* get item from the buffer */
item = get_from_buffer();
/* consume it */
consume(item);
} until done;
Sumber : http://www.csee.wvu.edu/~jdm/classes/cs550/notes/tech/mutex/pc-mon.html
6. Producer/consumer message passing solution
Melewati pesan di IPC: Solusi masalah Produser konsumen dengan menggunakan pemberian
pesan
Message passing adalah metode komunikasi antar proses yang digunakan dalam sistem
pemrograman paralel. Menggunakan dua fungsi panggilan: mengirim dan menerima untuk
mengirim dan menerima pesan. Dalam metode ini, penerima mengirim pesan pengakuan ke
pengirim ketika pesan diterima. Konsep pesan pengakuan digunakan untuk memastikan bahwa
pesan tidak hilang. Sebuah kotak yang digunakan untuk memegang pesan. sehingga pada
masalah produsen dan konsumen menggunakan Message passing.
#define MAX 100
void producer(void)
{
int item;
message mesg;
while (TRUE)
{
item = produce_item( );
receive(consumer, &mesg);
create_message(&mesg, item);
send(consumer, &mesg);

}
}
void consumer(void)
{
int item, i;
message mesg;
for (i = 0; i < MAX; i++)
send(producer, &mesg);
while (TRUE)
{
receive(producer, &mesg);
item = extract_item(&mesg);
send(producer, &mesg);
consume_item(item);
}
}
Sumber : http://www.moreprocess.com/process-2/message-passing-in-ipc-solution-ofproducer-consumer-problem-by-using
7. Simulation of Ricart and Agrawala Mutual Exclusion Algorithm
Algoritma Ricart dan Agrawala adalah sebuah algoritma untuk saling pengecualian pada sebuah
sistem terdistribusi. Algoritma ini merupakan perluasan dan optimalisasi dari Algoritma Lamport
Distributed Mutual Exclusion, dengan menghilangkan kebutuhan untuk pesan rilis.
Dikembangkan oleh Glenn Ricart dan Ashok Agrawala.
RECEIVING SITE:
Setelah penerimaan pesan permintaan, segera mengirimkan pesan balasan timestamped jika dan
hanya jika:
- proses penerimaan saat ini tidak tertarik pada bagian kritis
- proses penerimaan memiliki prioritas yang lebih rendah (biasanya ini berarti memiliki
timestamp)
Jika tidak, proses penerimaan akan menunda pesan balasan. Ini berarti bahwa balasan akan
dikirim setelah proses penerimaan selesai menggunakan critical section itu sendiri.

Bagian penting:
Situs -Requesting memasuki critical section hanya setelah menerima semua pesan balasan.
Algoritma ini bekerja sebagai berikut:
Ketika sebuah proses ingin memasuki wilayah kritis, membangun pesan yang berisi nama daerah
kritis itu ingin masuk, nomor proses dan waktu saat ini. Ia kemudian mengirimkan pesan ke
semua proses lain termasuk dirinya sendiri. Ketika proses menerima pesan permintaan dari
proses lain, tindakan yang dibutuhkan tergantung pada wilayahnya sehubungan dengan daerah
kritis yang disebutkan dalam pesan. Ada tiga kemungkinan:
-Jika Penerima tidak di daerah kritis dan tidak ingin memasukkannya, ia akan mengirimkan
kembali pesan OK ke pengirim (ditampilkan sebagai status Siap di meja kerja).
-Jika Penerima sudah di daerah kritis, tidak menjawab. Sebaliknya, antrian permintaan
(ditampilkan sebagai negara Dalam CS di meja kerja).
-Jika Penerima ingin memasuki wilayah kritis, tapi belum melakukannya, itu membandingkan
timestamp dalam pesan yang masuk dengan yang terkandung dalam pesan yang telah dikirim
orang. Yang terendah menang. Jika pesan yang masuk lebih rendah, penerima mengirimkan
kembali pesan OK. Jika pesan sendiri memiliki timestamp yang lebih rendah, penerima antrian
pesan yang masuk dan mengirimkan apa-apa (ditampilkan sebagai Menunggu negara dalam meja
kerja).
Setelah mengirimkan permintaan meminta izin untuk memasuki wilayah kritis, proses duduk
kembali dan menunggu sampai orang lain telah diberi izin. Begitu semua hak akses berada,
mungkin masuk ke daerah kritis. Ketika keluar dari daerah kritis, ia mengirimkan pesan OK untuk
semua proses pada antrian dan menghapus mereka semua dari antrian.
Meja kerja ini menampilkan sistem terdistribusi dengan empat node, setiap node memiliki
antrian permintaan dan antrian mengakui.
8. Simple solution to the bounded buffer problem
Bounded buffer problem adalah masalah sinkronisasi klasik untuk proses sekuensial co-operasi.
Sebuah contoh sempurna dari proses kerjasama berurutan adalah produsen dan konsumen
proses. Produsen menghasilkan barang dan konsumen yang dikonsumsi. Dalam produser
lingkungan penyangga dibatasi tidak bisa menghasilkan barang lebih dari ukuran buffer dan
konsumen tidak dapat mengkonsumsi barang-barang lebih dari ukuran buffer.
Solusi memori bersama untuk masalah ini ada yang menggunakan variabel counter bersama
diinisialisasi ke 0. Produser dapat menghasilkan max penyangga-1 item.

9. Implementation of Bounded Buffer problem using a counter variable

Buffer and counter variable dibagi antara 2 proses, masuk dan keluar, adalah variabel lokal untuk
produsen dan konsumen masing-masing.
Meskipun kedua produsen dan konsumen memiliki kode yang benar secara terpisah, tetapi pada
eksekusi bersama tidak dapat menghasilkan hasil yang benar karena kondisi balapan dan tidak
ada mekanisme sinkronisasi yang tepat ada.
Solusi lain untuk masalah budder dibatasi di mana tidak ada kondisi ras . Solusi ini memanfaatkan
Semaphore. Dalam masalah ini diasumsikan bahwa ada eksis n buffer masing-masing ukuran 1
bukan satu penyangga ukuran n. Juga, tiga Semaphore digunakan. Salah satunya adalah mutex
digunakan untuk menyediakan saling pengecualian di bagian kritis dan diinisialisasi ke 1.
Semaphore kosong dan penuh menghitung jumlah buffer kosong dan penuh, dan siap untuk
melakukan n dan 0 masing-masing.

10. Showing problems with atomicity and mutual exclusion using the Bounded Buffer with
counter solution
Dalam komputasi, masalah produsen-konsumen (juga dikenal sebagai masalah bounded-buffer)
adalah contoh klasik dari masalah sinkronisasi multi-proses. Masalahnya menggambarkan dua
proses, produsen dan konsumen, yang berbagi umum, tetap ukuran buffer yang digunakan
sebagai antrian. Pekerjaan produser adalah untuk menghasilkan sepotong data, memasukkannya
ke dalam buffer dan mulai lagi. Pada saat yang sama, konsumen mengkonsumsi data (misalnya,
mengeluarkannya dari buffer) satu bagian pada suatu waktu. Masalahnya adalah untuk
memastikan bahwa produsen tidak akan mencoba untuk menambahkan data ke buffer jika penuh
dan bahwa konsumen tidak akan mencoba untuk menghapus data dari buffer kosong.
Solusinya bisa ditempuh dengan sarana komunikasi antar-proses, biasanya menggunakan
Semaphore.

Pada proses ini, Producer dan Consumer memiliki method yang berbeda, dimana dalam
consumer memerlukan counter untuk menggunakan bufer , dimana jika menggunakan buffer
counter akan berkurang (1) sesuai dengan yang di gambar di atas, sedangkan producer

menggunakan buffer sebagai alat penyimoanan sehingga counter yang digunakan akan
bertambah (1) seperti di gambar.
Source.
http://williamstallings.com/OS/Animation/Queensland/BB_WRONG.SWF
http://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem
11. Mutual exclusion with a semaphore
Mutual exclusion mengacu pada kebutuhan untuk memastikan bahwa tidak ada dua proses
konkuren berada di critical section pada saat yang sama; itu merupakan kebutuhan pokok dalam
kontrol concurrency, untuk mencegah kondisi balapan.
Sehingga Mutex (Mutual exclusion) dengan semaphore dapat di contohkan dalam proses ini
Semaphore adalah hal-hal yang dimaksudkan untuk melewatkan sinyal antara thread atau
proses. Sebuah proses dapat menunggu semaphore: ini berarti ditunda sampai beberapa proses
lain sinyal semaphore. Jika semaphore telah mengisyaratkan, namun, ketika proses menunggu,
itu tidak benar-benar menunda, tetapi tetap berlanjut secara bertahap.
Dengan method waiting Mutex

Nilai value akan terus berubah sesuai dengan ketentuan di setiap proses sehingga bila value
kurang dari nilai 0, akan menjalankan ketentuan yang ditetapkan, yaitu masuk ke dalam mutex
list dan proses akan di blocking.

Dalam proses ini menjelaskan, karena proses A sudah melewati critical section yang di karenakan
harus berpindah proses, sedangkan proses lain akhirnya ter hambat / block. Proses A akhirnya
bisa menjalankan method ke-2 yaitu signal (Mutex) yang terlihat pada gambar. Sehingga dengan
ketentuan signal ( Mutex) dapat membuka Blocked Path di setiap proses dan berjalan sesuai
dengan methodnya.
12. Process synchronization with semaphores
Semaphore dalam proses ini dapat digunakan sebagai pengatur tahapan-tahapan pada proses
yang bekerja secara bersamaan yang sedang berjalan.
Seperti ini contohnya

Di setiap proses memiliki ketergantungan satu sama lain sehingga, saling memerlukan bantuan
untuk menjalankan proses tersebut, atau biasa disebut dengan concurrent process.

Sumber
https://www.classes.cs.uchicago.edu/current/51081-1/LabFAQ/lab7/Semaphores.html
http://www.cs.unc.edu/~dewan/242/s04/notes/intro/node21.html