Mediaspace scheduled maintenance: Aug 25, 2026 07:00 - 12:00 AM. During this time, videos will be temporarily unavailable. Check status updates.

Lecture

One-place Buffer: Monitor-based Implementation

Related lectures (32)

Dining philosopher problem

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

Concurrency Overview

Explores the significance of concurrency in enhancing system performance and responsiveness, emphasizing the need for synchronization and atomicity to prevent race conditions and non-determinism.

Concurrency with Futures

Explores futures as a structured approach to concurrency, simplifying parallel tasks and input-output 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.

Parallel Programming: Fundamentals

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

Concurrency and Parallelism: Visibility

Explores visibility in concurrency, memory models, shared memory, and hardware optimizations.

Actors: Evolution and Implementation

Covers the evolution of Actors, challenges of modern CPUs, parallel programming risks, and synchronization tools in Scala.

Locks: Implementing Concurrency Mechanisms

Covers the implementation of locks using compareAndSet and the concept of fair locks.

Concurrency Basics: Threads and Synchronization

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

Sequential consistency: Basic Concepts

Explains the Sequential Consistency model in concurrency and parallelism, covering program order, atomicity, and performance implications.

Atomic Operations: Basics and Applications

Covers the basics of atomic operations in concurrency and parallelism, including hardware-provided operations and synchronized algorithms.

Introduction to Concurrency

Covers the basics of concurrency, its importance, and how to write concurrent programs.

Concurrency Semantics and Verification

Explores concurrency semantics, recursive functions, loops, interleaving modeling, and interpreter verification.

Readers-writer Lock

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

Asynchronous Programming with Futures

Explores asynchronous programming with futures, showcasing benefits, challenges, and efficient implementations.

Synchronization Inference

Explores automatic synthesis of correct and efficient synchronization in programs, focusing on removing redundant atomicity and adding synchronization metadata.

Dining Philosophers Problem

Discusses algorithms to prevent starvation and maximize philosophers eating simultaneously.

Concurrency and Parallelism: Queue

Explores thread safety, synchronization, and concurrent collections in Scala, focusing on a lock-free concurrent queue implementation.

Scalable Synchronization Mechanisms for Manycore Operating Systems Log in to Mediaspace to watch this video

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

Concurrency Control & Recovery in Databases Log in to Mediaspace to watch this video

Delves into transaction management, concurrency control, and recovery in databases to ensure data integrity and system resilience.