Part A - Multithreading & Thread Synchronization - Pthreads

Understand singularism, doing tasks one at a time with no pre-emption, illustrated by three well diggers, and compare it to concurrency and parallelism regarding progression and speed.

Map the well-digging analogy to the multithreading world by equating workers to threads, resources to cpu and memory, and transitions to context switching.

Explore how concurrency enables multithreaded design when input/output waits occur alongside ongoing work, illustrated by a network application with threads for packet arrival, periodic sending, and user input.

Design a multithreaded tcp server by delegating each client to its own worker thread, isolating communication and enabling parallel handling of multiple independent connections.

Threads are lightweight processes because they reuse the main thread’s resources—page tables, shared libraries, and sockets—avoiding re-creation; resources remain for other threads, so thread switching is faster.

Identify overlapping and non-overlapping work between threads accessing the same data structure, using examples like array sorts, to decide if synchronization is required before applying mutexes or condition variables.

Explain joinable and detached threads in Pthreads, including how a parent thread joins a child, blocks at join, releases resources after join, and that the default is joinable with conversion.

Learn how detached threads release resources automatically after termination, without join operations, while joinable threads require joining; they can be converted to joinable during execution; includes a demo.

Explain that any thread can wait for any other joinable thread with pthread_join, as parent, child, and grandchild illustrate join points and the rule against joining detached threads.

Learn the mapreduce paradigm by splitting a large text into ranges, assigning them to mapper threads, and using a reducer that joins results to output the final word count.

Choose joinable threads when a thread returns a result or others must be notified of termination; use detached threads for infinite loops or waiting for input, like TCP servers.

Explore the difference between transfer of data and transfer of computation, contrasting sending data across entities with sending a function pointer within the same process to perform computation.

Discover notification chains as an architectural design pattern for notifying multiple subscribers about publisher events, where publishers emit events that subscribers register to receive across threads, processes, or components.

Understand the publisher–subscriber model and notification chains, where subscribers register with keys or wildcards and publishers invoke callbacks on updates. See separate notification chains per data source.

Design and implement a generic notification chain in C, a linked list of notification chain elements with keys and function pointers, plus a generic callback prototype.

Implement a publisher-subscriber model with a routing table data source, where one publisher thread serves four entries and three subscriber threads subscribe to specific entries via per-entry notification chains.

Model a routing table as a data source using a doubly linked list, defining keys (destination, mask) and entries with interface and gateway, and implement CRUD APIs.

implement subscriber support in threaded_subscriber.c by creating a detached subscriber thread, subscribing to random routing table entries, and handling publisher notifications via a test callback, integrating with the notification chains.

Implement subscription and notification in a publisher-subscriber model using a routing table data source; let subscribers express interest and receive updates when the publisher modifies entries.

Implement the subscription API to register subscribers for routing table entries, create entries when needed, initialize and register notification chain elements, and immediately notify entries with the NFC add opcode.

Enhance the routing table with a notification chain that informs all subscribers on updates, additions, and deletions, distinguishing publisher updates from subscriber creates and ensuring proper memory cleanup.

Demonstrate inter-thread communication via a publisher-subscriber model, where the publisher updates a routing table and notifies subscriber threads with the new data.

Explore thread cancellation, stopping a running thread to cancel ongoing searches, periodic packets, or file downloads, with any thread in the same process able to cancel another and terminate it.

Learn how to implement asynchronous thread cancellation in POSIX threads by using pthread_cancel, pthread_setcancelstate, and pthread_setcanceltype, including making threads cancelable and the limits of canceling non-cancellable threads.

Illustrate how asynchronous thread cancellation can leave data structures in an invariant state, causing corruption, memory leaks, and wrong results, with examples from doubly linked lists and balanced trees.

Install and balance pthread cleanup handlers in the thread function to free heap memory and close a file upon cancellation, and then demonstrate with a compile-and-run script.

Understand listener threads and their slave design that monitor external events—packets arriving on UDP sockets, kernel events, and user input—and delegate processing to the main process without blocking.

Launch two UDP listener threads on 127.0.0.1 ports 3000 and 3001 to feed packets into the main application via a simple receive function, while a third thread handles user interaction.

Create two listener threads on ports 3000 and 3001 using server_create_and_start with ip 127.0.0.1, and implement a packet_receive function that prints received packet and its size, then exits via pthread_exit.

Implement a UDP packet listener thread in C using pthreads: create a detached thread, bind a UDP socket to IP address and port, and invoke a callback on packet arrival.

Identify critical sections that access shared data, such as global variables or file descriptors, and synchronize them so only one thread accesses them at a time to prevent data corruption.

Learn how mutexes enforce mutual exclusivity to protect a critical section in multithreading, using the locker-key analogy to illustrate access control and practice through problems.

Master mutex rules for thread synchronization: only the locking thread should unlock its mutex, and avoid unlocking an already unlocked mutex; blocking, scheduling, and the reverse-order unlock complete correct usage.

Explore mutex locking and differentiate code locking from object locking, using a global mutex in a file to protect critical sections with pthread mutex lock and unlock.

Data locking uses a mutex owned by each list object to guard its critical sections, enabling concurrency across different lists and avoiding unnecessary blocking from code locking.

Explore a mutexes in action demonstration where two threads read and write a shared array, producing undefined behavior, then learn to enforce mutual exclusion with mutexes.

Deploy mutexes to enforce mutual exclusion between two threads accessing a shared array, guarding read and write operations and ensuring the sum equals 15.