Lecture

Concurrency: Executors and Mutual Exclusion

Related lectures (32)

Covers the importance of concurrency, atomic operations, and mutual exclusion using locks.

Locking Primitives: Avoiding Race Conditions in Threads

Covers locking primitives necessary to prevent race conditions in multithreaded programming, focusing on mutual exclusion and atomic operations.

Monitors: Synchronization and Cooperation

Explores monitors as a synchronization construct providing mutual exclusion and cooperation among threads, with examples like the one-place buffer.

Concurrency Properties: Basics and Locks

Explores concurrency properties, race conditions, and the basics of locks.

Concurrency Primitives and Pitfalls

Explores concurrency primitives, mutual exclusion, and synchronization pitfalls in operating systems, focusing on condition variables and semaphores.

Readers Writer's Lock

Covers the concept of Readers Writer's lock and its synchronization between readers and writers using atomic variables.

Readers-writer Lock

Introduces the readers-writer lock for handling concurrency in scenarios with frequent reads and occasional updates.

Mutexes: Managing Thread Synchronization

Explains mutexes as thread locks, addressing busy waiting and ensuring efficient synchronization in multi-threaded applications.

Locking

Explores the concept of locking for mutual exclusion in OS, covering race conditions, parallelism, atomic instructions, deadlock prevention, and best practices.

Lock-Free Synchronization: Practical Insights

Explores the significance of lock-free synchronization for achieving low latency in distributed systems and discusses practical solutions for unique identifier generation and messaging queues.

Synchronization: Locks and Barriers

Explores synchronization principles using locks and barriers, emphasizing efficient hardware-supported implementations and coordination mechanisms like OpenMP.

Scalable Synchronization Mechanisms for Manycore Operating Systems

Explores scalable synchronization mechanisms for many-core operating systems, focusing on the challenges of handling data growth and regressions in OS.

Parallel Programming: Fundamentals

Covers the basics of parallel programming, including exploiting parallelism in algorithms and the importance of avoiding race conditions.

Concurrency Basics: Threads and Synchronization

Covers the basics of concurrency, focusing on threads and synchronization, including thread joining and challenges of non-deterministic execution.

Threads: Introduction and Implementation

Introduces thread creation and management in Java, including using thread pools for efficient task execution.

Dining philosopher problem

Presents an algorithm to prevent starvation and maximize philosophers eating simultaneously.

One place buffer: Producer-consumer queue

Introduces the concept of a one-place buffer in concurrent programming.

Advanced Synchronization & Transactional Memory

Covers advanced synchronization techniques, atomic operations, lock implementations, and hardware support for queue locks.

Lock-Free Synchronization: Performance and Scalability

Explores lock-free synchronization for performance and scalability in distributed systems, covering unique identifier generation, messaging queues, and atomic RDMA reads.

Memory Consistency: Taking it to the Compiler

Explores memory consistency, weak consistency, and language-level guarantees in memory ordering, emphasizing the importance of data race free programming.