8.6.1. Locks and Semaphores

Synchronization is essential in multicore systems to coordinate the execution of threads and prevent data corruption due to concurrent access to shared resources.

Synchronization is a crucial aspect of multicore systems because multiple threads (or processes) may try to access the same data or resources at the same time. If these threads run independently without any control, they can overwrite each other's data, leading to inconsistencies and errors. Therefore, synchronization mechanisms are needed to manage access to shared resources, effectively allowing only one thread at a time to access a particular resource.

Think of a busy kitchen where multiple chefs are using the same cutting board. If they don't take turns, they might accidentally knock each other out of the way, leading to mistakes. In this scenario, a system of taking turns (like a semaphore) or setting a single chef at a time at the cutting board (like a lock) ensures that the kitchen runs smoothly without any collisions.

Locks and Semaphores: Common mechanisms used to ensure that only one thread or core can access a shared resource at any time. Locks can be coarse-grained or fine-grained, depending on the level of granularity required.

Locks are mechanisms used to protect shared resources by allowing only one thread to access the resource at a time. When a thread wants to use a resource, it will 'acquire' a lock. If the lock is already taken by another thread, the requesting thread will have to wait until the lock is released. Locks can vary in granularity: coarse-grained locks cover a larger resource (e.g., protecting an entire database), while fine-grained locks protect smaller resources (e.g., individual records within that database). Fine-grained locks allow for more parallelism but can be more complex to implement.

Imagine a library where only one person can borrow a specific book at a time. If someone is reading it, others must wait until it is returned. The book acts like a lock; only one person can hold it at a time. If multiple people tried to take it simultaneously, chaos would ensue. By using this system (the lock), the library maintains order and ensures that each person can eventually read the book.

Atomic Operations: Operations that execute as a single, indivisible unit, ensuring that no other core or thread can intervene while the operation is in progress.

Semaphores are synchronization tools that manage access to a common resource by multiple threads. Unlike locks, which only allow one thread access, semaphores can permit a defined number of threads to access a resource concurrently. This is useful when a resource can be shared among multiple threads simultaneously but still requires control to prevent overload. Semaphores can be 'binary' (like a lock, which is either acquired or not) or 'counting' (allowing multiple threads up to a specific limit).

Consider a public restroom that has more than one stall. A semaphore in this case could represent the number of stalls available. If there are three stalls and three people enter, one additional person would need to wait until someone exits (the semaphore count would decrease and then increase as individuals exit). This system allows for efficient use of resources, as multiple people can use the restroom simultaneously, but it also controls the number, preventing overcrowding.

--