Operating System Concepts Chapter 5.4

Study Notes

A solution to the producer-consumer problem involves using an integer counter to keep track of the number of full buffers.
The producer increments the counter after producing a new buffer, and the consumer decrements the counter after consuming a buffer.

A race condition occurs when the execution of two or more processes overlaps, causing unexpected results.
In the context of the producer-consumer problem, a race condition can occur when the producer and consumer access the shared counter simultaneously.

The critical section problem involves designing a protocol to allow multiple processes to access a shared resource without conflicts.
Each process has a critical section of code that must be executed exclusively, ensuring that no other process can access the shared resource simultaneously.
The critical section problem can be solved using a protocol that allows processes to request permission to enter the critical section and ensures that only one process can access the shared resource at a time.

One solution to the critical-section problem involves using a shared variable turn to indicate which process can enter the critical section.
Each process waits until turn equals its process number before entering the critical section.
After finishing the critical section, the process sets turn to the next process number.

Another solution to the critical-section problem involves using a shared Boolean variable lock and the test_and_set() function.
The test_and_set() function atomically sets lock to TRUE if it is FALSE, and returns the old value of lock.
A process waits until lock is FALSE before entering the critical section, and sets lock to TRUE to prevent other processes from entering.

A semaphore is a variable that can only be accessed using two indivisible operations: wait() and signal().
wait() decrements the semaphore value, and if the value is negative, the process blocks.
signal() increments the semaphore value, and if a process is blocked, it is awakened.

Deadlock occurs when two or more processes are waiting indefinitely for an event that can only be caused by one of the waiting processes.
Starvation occurs when a process is indefinitely blocked due to a semaphore.
Priority inversion is a scheduling problem that occurs when a lower-priority process holds a lock needed by a higher-priority process.

The bounded-buffer problem involves synchronizing access to a finite buffer by multiple producers and consumers.
The readers-writers problem involves synchronizing access to a shared resource by multiple readers and writers.
The dining-philosophers problem involves synchronizing access to a shared resource (chopsticks) by multiple philosophers.