Concurrent and Parallel Programming

  1. Synchronization Primitives
    1. The Need for Synchronization
      1. Protecting Critical Sections
        1. Ensuring Atomicity
          1. Ensuring Ordering
            1. Preventing Data Races
            2. Locks and Mutexes
              1. Mutual Exclusion Principle
                1. Lock Acquisition
                  1. Lock Release
                    1. Types of Locks
                      1. Spinlocks
                        1. Reentrant Locks
                          1. Reader-Writer Locks
                          2. Lock Contention and Performance
                            1. Deadlock Risks with Locks
                            2. Semaphores
                              1. Counting Semaphores
                                1. Binary Semaphores
                                  1. Semaphore Operations
                                    1. Wait Operation
                                      1. Signal Operation
                                      2. Producer-Consumer Problem Solution
                                        1. Semaphore Limitations
                                          1. Semaphore Pitfalls
                                          2. Monitors
                                            1. High-Level Synchronization Construct
                                              1. Encapsulating Shared Data
                                                1. Encapsulating Procedures
                                                  1. Implicit Mutual Exclusion
                                                    1. Condition Variables Within Monitors
                                                    2. Condition Variables
                                                      1. Waiting for Specific Conditions
                                                        1. Signaling
                                                          1. Broadcasting
                                                            1. Spurious Wakeups
                                                              1. Usage with Mutex
                                                                1. Producer-Consumer Example
                                                                2. Atomic Operations
                                                                  1. Hardware-Level Atomicity Guarantees
                                                                    1. Types of Atomic Operations
                                                                      1. Compare-and-Swap
                                                                        1. Fetch-and-Add
                                                                          1. Test-and-Set
                                                                          2. Use in Lock-Free Programming
                                                                            1. Atomic Operation Limitations
                                                                              1. Hardware Support Requirements
                                                                              2. Barriers
                                                                                1. Synchronizing Thread Groups at Points
                                                                                  1. Use Cases in Parallel Algorithms
                                                                                    1. Barrier Implementation Strategies

                                                                                  Previous

                                                                                  2. Fundamental Concepts

                                                                                  Go to top

                                                                                  Next

                                                                                  4. Concurrency Models and Patterns