Month: November 2018

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;

}

}

https://stackoverflow.com/questions/9700871/what-is-difference-between-sleep-method-and-yield-method-of-multi-threading

We can prevent a thread from execution by using any of the 3 methods of Thread class:

• yield()
• join()
• sleep()

yield() method pauses the currently executing thread temporarily for giving a chance to the remaining waiting threads of the same priority to execute. If there is no waiting thread or all the waiting threads have a lower priority then the same thread will continue its execution. The yielded thread when it will get the chance for execution is decided by the thread scheduler whose behavior is vendor dependent (i.e., yield() can only make a heuristic attempt to suspend the execution of the current thread with no guarantee of when will it be scheduled back).

join() The current thread can invoke join() on any other thread which makes the current thread wait for the other thread to die before proceeding. If any executing thread t1 calls join() on t2 (i.e, t2.join()) immediately t1 will enter into waiting state until t2 completes its execution.

sleep() method can force the scheduler to suspend the execution of the current thread for a specified period of time as its parameter.

Thread Synchronization

https://docs.oracle.com/javase/tutorial/essential/concurrency/sync.html

• Mutex Semaphore (aka Mutex) controls only one thread at a time executing on the shared resource by lock & unlock.
• Counting Semaphore (aka Semaphore – Java7) controls the number of threads executing on the shared resource by acquire & release.
• Monitor controls only one thread at a time, and can execute in the monitor (shared object) by wait & notify/notifyAll.

Process vs Thread

https://docs.oracle.com/javase/tutorial/essential/concurrency/procthread.html

Project Jigsaw (Java9)

https://infoscis.github.io/2017/03/24/First-steps-with-java9-and-jigsaw-part-1/

https://infoscis.github.io/2017/03/24/First-steps-with-java9-and-jigsaw-part-2/

http://greatkim91.tistory.com/197