CST334 - Week 6 Reflection

 Weekly Learning Reflection

        The core focus this week was firmly rooted in safely managing access to shared resources using synchronization primitives like mutex locks, semaphores, and condition variables. I learned that mutexes are essential for protecting critical sections, ensuring that only one thread can access shared data at a time. We extended this idea by using condition variables (pthread_cond_t) to block threads until specific conditions are met, a powerful tool for coordinating complex thread interactions. I applied this in the big readers-writers assignment this week, where multiple threads may read from a shared database concurrently, but writes must happen exclusively. Implementing this pattern required carefully checking conditions, signaling waiting threads, and managing a maximum number of concurrent readers to avoid race conditions or deadlocks. I loved how well the lecture and reading matched up with the programming assignment this week. Practicing/learning about semaphores in producer-consumer scenarios allowed me to manage access to finite resources like buffer slots, where producers must wait if the buffer is full, and consumers must wait if it is empty. Modifying a web server to be multi-threaded using pthread_create and pthread_detach, which enabled simultaneous handling of multiple client requests reinforced the practical importance of thread-safe data structures and proper synchronization in real-world applications. Professor Ogden's breakdown of the Anderson/Dahlin method additionally contextualized the involved tools as well as a foolproof implementation workflow.

        Together, these activities helped me connect abstract concepts like mutual exclusion, deadlock prevention, and resource scheduling to real implementations in C. I now better understand how to build thread-safe systems and coordinate concurrent workloads. This week’s learning not only improved my confidence working with threads but also highlighted how fundamental synchronization is in building reliable, high-performance systems.