Month: November 2019

Reader-Writer Problem using Semaphore

Reader() { // multiple readers can read the data at the same time when there is no writer

P(rmutex); // lock for nreaders
nreaders++; // # of reader count increase
if (nreaders == 1) P(rwmutex); // if there is the first reader, lock writer mutex (reader들이 읽는 동안 writer는 접근 못하도록)
V(rmutex); // unlock for nreaders

<<< critical section: Read data  >>> reader들은 writer가 사용하지 않을시 동시에 여러 개가 접근 가능

P(rmutex); // lock for nreaders
nreaders–; // # of reader count decrease
if (nreaders == 0) P(rwmutex); // if there is no reader, unlock writer mutex (reader가 더이상 없으면 writer가 접근 가능하도록)
V(rmutex); // unlock for nreaders

}

Writer() { // only one writer can write data at a time when there is no reader

P(rwmutex); // lock writer mutex

<<< critical section: Writer data >>>writer는 reader가 사용하지 않을시 한번에 하나씩 접근 가능

V(rwmutex); // unlock for writer mutex
}

BoundedBuffer Producer Consumer Problem (condition) (cpp11)
thread-cpp11-boundedbuffer

Java BoundedBuffer Producer Consumer Problem (Condition) (updated)
multithread-java-ProducerConsumerCondition

Java BoundedBuffer Producer Consumer Problem (Semaphore)
multithread-java-ProducerConsumerSemaphore

Java BoundedBuffer Producer Consumer Problem (Monitor)
multithread-java-ProducerConsumerMonitor

Producer-Consumer Problem using Semaphore

Producer() {

put(item) {

P(empty); // for wait, Get an empty count, block if unavailable
P(mutex); // lock critical section: shared buffer
<<< critical section: Put item into shared buffer >>>
V(mutex); // unlock critical section
V(full); // for signal, increase number of full count

}

}

Consumer() {

take () {

P(full); // for wait, Get a full count, block if unavailable
P(mutex);
<<< critical section: Take item from shared buffer >>>
V(mutex);
V(empty); // for signal, increase number of empty count
return item;

}

}

Producer-Consumer Problem using Monitor

Producer() {

synchronized put(item) {

while(count >= buffer.length) { wait(); } // wait if buffer is full
count++
<<< critical section: Put iteminto shared buffer >>>
notifyAll(); // signal

}

}

Consumer() {

synchronized take () {

while(count <=0) { wait(); } // wait if buffer is empty
count- –
<<< critical section: Take itemfrom shared buffer >>>
notifyAll(); // signal
return item;

}

}

Mutual Exclusion
https://en.wikipedia.org/wiki/Mutual_exclusion

Mutex (Mutual Exclusion) – binary semaphore

Semaphore (counting semaphore) is a main synchronization primitive in early operating system developed by Edsger W. Dijkstra (1965).
https://en.wikipedia.org/wiki/Semaphore_(programming)

https://os.mbed.com/users/takashikojo/notebook/r/

Monitor is a high-level synchronization primitive developed by Per Brinch Hansen(1973) and C. A. R. Hoare(1974)

https://en.wikipedia.org/wiki/Monitor_(synchronization)
https://www.artima.com/insidejvm/ed2/threadsynchP.html