第6章インフラストラクチャーの抽象化層：オペレーティングシステム

Synchronization in concurrent programming is crucial for ensuring that multiple threads or processes can work together without interfering with each other’s operations on shared resources. Through mechanisms like locks, condition variables, and semaphores, developers can design systems that are both efficient and safe, avoiding issues such as data races and deadlocks. One way of coordinating multiple concurrent activities that are using shared state is synchronization, which groups operations together automatically to ensure cooperation between threads. To ensure that only one thread does a particular task at a time, we can use a program called mutual exclusion that prevents simultaneous access to a shared resource. A critical section is a piece of code that only one thread can execute at once. Also, only one thread at a time will get into this section of code. A critical section is the result of mutual exclusion. Critical sections and mutual exclusion are in fact two ways of describing the same thing. Critical sections are sequences of instructions that may get incorrect results if executed simultaneously. Mutual exclusion is required to ensure that a process cannot enter its critical section while another concurrent process is currently present in its critical section. Figure 6.24 illustrates a representation of two processes, process P1 and process P2. At Time 1, process P1 entered the critical section by printing on a shared printer. Process P1 will finish printing at Time 2. While process P1 is printing, process P2 is attempting to print, but the OS will block process P2 from printing until process P1 reaches Time 2.

A lock is a synchronization mechanism that is used to enforce mutual exclusion. A thread must acquire a lock before entering a critical section; if the lock is already held by another thread, the attempting thread will block until the lock becomes available. Another synchronization mechanism called a condition variable is used in conjunction with locks to allow threads to wait for certain conditions to become true. While a lock facilitates exclusive access to resources, a condition variable helps threads wait for specific states of the world.

A classic example of a synchronization challenge is the producers/consumers problem, where producers generate data and place it into a buffer, and consumers remove data from the buffer for processing. In a producer/consumer scenario, a consumer might wait on a condition variable if the buffer is empty, and a producer might signal this variable once it adds an item to the buffer. The key concerns associated with this scenario include ensuring that producers don’t add data to a full buffer and that consumers don’t try to remove data from an empty buffer. Synchronization tools like locks and condition variables are used to solve these issues. A deadlock occurs when a set of threads are blocked forever, waiting for each other to release resources. This can happen, for example, if thread A holds lock 1 and waits to acquire lock 2, while thread B holds lock 2 and waits to acquire lock 1. Avoiding deadlocks requires careful design, such as acquiring locks in a consistent order or using timeout mechanisms.

Some other tools used in synchronization are:

• Semaphores: Similar to locks, but allow multiple threads to access a finite number of resources

• Barriers: Enable multiple threads to wait until all have reached a certain point in their execution before any are allowed to proceed

• Read-Write Locks: Allow multiple readers to access a resource concurrently but require exclusive access for writers

• Mailboxes: Dedicated channels that connect two processes directly, allowing data to be exchanged between them; mailboxes behave like queues but use semaphores for controlled automatic access, and operate in first in, first out (FIFO) order only.