Part B (ADVANCE) Multithreading Design Patterns ( pthreads )

Define a thread data structure and prototype three APIs for a multithreaded library, then implement create, run, and a general or dance mode toggle to initialize and start threads.

Learn how to pause and resume pthreads using mutex and condition variables, including cancellation points and building custom apis, while avoiding invariance and resource leaks.

Take a learning break to explore the globalist linked list as a new approach, using it as a supporting data structure for future assignments with a working implementation.

Explore thread pool data structures and apis for implementing multithreading design patterns. Build a linked list based thread pool with mutex protection and management apis for adding or removing threads.

Begin implementing a pthreads thread pool by initializing the pool, inserting and fetching threads with a mutex-protected linked list, and starting the dispatch logic while integrating the dual thread library.

Learn to implement a pthreads thread pool API: enqueue threads into the pool, block them on a condition variable, then dispatch by creating the execution unit or signaling the thread.

Demonstrates a thread pool by creating and initializing two threads, dispatching functions that print even and odd numbers in reverse and normal order, with sleeps.

Implement step seven as an optional notification from the worker thread to the application. A boolean flag decides whether the application blocks; use zero semaphores, with condition variables as an alternative.

Understand barrier synchronization in multithreaded programs: a barrier threshold blocks threads at a barrier point until the required number arrives, then releases all and transitions through disposition until completion.

Compare the test_and_wait API with the standard two-state locking procedure, mapping lock mutex, predicate check, block on the condition variable, wake, recheck, enter the critical section, and unlock.

Implement and initialize wait queues in a pthreads-based multithreading design patterns course, wiring up data structures, APIs, and three-step signaling with mutexes and condition variables.

Design a traffic light data structure with color and direction enumerations, implement a traffic light phase, manage per-face mutex and wait queues, and expose initialization and status APIs.

Model moving traffic with threads approaching traffic light faces, using per-phase wait queues and mutexes, plus thread private data and state enumeration to block on red and resume on green.

Explain what recursive mutexes are, why they prevent deadlocks by allowing the same thread to lock multiple times, and how to enable and use them with POSIX mutex attributes.

Explore when to use recursive mutexes in multithreaded software, showing how nested API locks can deadlock with normal mutexes and how recursive locks enable safe re-entry.

Explore Reed Wright locks and mutex concepts, review in-built API support, examine use cases, then write your own implementation to gain conceptual clarity.

Learn to implement a read-write lock from scratch, ensuring reader and writer coordination, support for recursion, correct unlock semantics, and crash-on-invalid unlock, using only condition variables and mutexes.

Learn to implement a read-write lock using a state mutex, a condition variable, and counters to manage access and ownership by readers and writers.

Explore how monitors generalize read-write locks to coordinate threads, enabling customizable cooperation schemes and problem-specific synchronization for multithreading with pthreads.

Upgrade the rewrite lock to a monitor by applying five customizations, making the read-write lock configurable, and setting up a monitor directory for upcoming changes.

Implement the replacement property in a pthreads monitor by updating the unlock API to signal waiting readers and writers, achieving symmetric read and write locking.