13 - Synchronization

Question 1

What are mutexes and their role in synchronization?

Answer 1

• Mutexes guard critical regions and implement mutual exclusion.
• Lock and unlock actions should be performed by the same task.
• They are used for simple interactions where only one task runs protected code.

Question 2

What are different synchronization patterns in multi-threaded programs?

Answer 2

• Multi-threaded programs may require synchronization for different resource guarding and just thread execution coordination.
• Some patterns involve waiting inside a critical region for different events or conditions.

Question 3

What are condition variables in Linux programming?

Answer 3

• Condition variables allow threads to wait inside critical regions without holding the lock, enabling other threads to enter.
• They make it possible to sleep inside a critical section and atomically release and reacquire the lock.

Question 4

How does waiting inside a critical region work in thread synchronization?

Answer 4

• Waiting inside critical regions is crucial for long critical sections as it serializes code and affects concurrency.
• Threads wait for specific conditions or events, which is impossible with regular mutexes

Question 5

Describe the operations associated with condition variables.

Answer 5

• Wait(): Atomically releases the lock and puts the thread to sleep; the lock is reacquired upon waking up.
• Signal(): Wakes up one waiting thread, if any.
• Broadcast(): Wakes up all waiting threads.

Question 6

How do mutexes interact with condition variables in thread synchronization?

Answer 6

• A mutex is used alongside a condition variable to protect the critical region where threads wait.
• The wait operation on a condition variable releases and then reacquires the corresponding mutex, ensuring only one thread is in the critical region.

Question 7

What are the key pthread procedures for managing condition variables?

Answer 7

• pthread_cond_init(pthread_cond_t *cv, NULL);
• pthread_cond_destroy(pthread_cond_t *cv);
• pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *lock);
• pthread_cond_signal(pthread_cond_t *cv);

Question 8

How are condition variables created and used in pthreads?

Answer 8

• Condition variables are declared with pthread_cond_t and must be initialized.
• Initialization can be static (with PTHREAD_COND_INITIALIZER) or dynamic (with pthread_cond_init()).
• pthread_cond_destroy() is used to free a condition variable when it’s no longer needed.

Question 9

Explain the pthread_cond_wait function in pthreads.

Answer 9

• pthread_cond_wait() is used when a thread wants to block and wait for a condition to be true.
• The function assumes the thread has locked the mutex. It releases the mutex and blocks until awakened by pthread_cond_signal() from another thread.
• Upon awakening, it waits to reacquire the mutex before returning.

int pthread_cond_wait(pthread_cont_t * cv, pthread_mutex_t * mux);

Question 10

Explain the pthread_cond_signal function used with condition variables.

Answer 10

• pthread_cond_signal checks for any threads waiting on the specified condition variable.
• If threads are waiting, one is awakened.
• It does not guarantee the order in which threads are awakened. For waking all threads, pthread_cond_broadcast is used.

Question 11

Can you describe the use of condition variables with an example of the producer-consumer problem?

Answer 11

• In the producer-consumer problem, the producer thread produces data and signals the condition variable when data is available.
• The consumer thread waits on the condition variable until data becomes available.
• Mutex locks are used in conjunction with the condition variable to protect the shared data.

Question 12

What are spurious wake-ups in the context of condition variables and how are they handled?

Answer 12

• Spurious wake-ups occur when a thread is awakened without any thread signaling the condition variable.
• They are handled by looping around the pthread_cond_wait call and checking the condition upon wake-up.
• This ensures that the thread only proceeds if the condition is actually true.

Question 13

What are read-write locks and how do they function in multi-threaded programming?

Answer 13

• Read-write locks allow multiple threads to read a shared resource concurrently but require exclusive access for writing.
• They prevent write starvation by not allowing new read locks if a write lock is waiting.
• This mechanism ensures efficient access for read-heavy resources while maintaining data integrity during writes.