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

Lecture

Dining philosopher problem

Related lectures (47)

Concurrency Basics: Threads and Synchronization

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

Monitors: Synchronization and Cooperation

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

Atomic Operations: Basics and Applications

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

Memory Models: Visibility and Semantics

Explains the Java Memory Model and thread start semantics for concurrent programs.

Sequential consistency: Basic Concepts

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

Concurrency and Parallelism: Queue

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

Concurrency: Deadlock

Covers the concept of deadlock in concurrent programming and provides solutions to prevent them.

Introduction to Concurrency

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

Akka Streams: Programming Reactive Systems

Covers Akka Streams basics, stream stages concurrency, materialized values, and more.

Principles of Parallelism

Covers the basics of parallelism, including physical examples, historical context, multicore era, and parallel collections in Scala.

Readers-writer Lock

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

Threads and Locks

Explores threads in programming, shared data challenges, locks, and thread management in graphical interfaces and web applications.

Concurrency with Futures

Explores futures as a structured approach to concurrency, simplifying parallel tasks and input-output operations.

One place buffer: Producer-consumer queue

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

Parallelism and Concurrency

Covers the course CS206 on Parallelism and Concurrency, including logistics, materials, exercise sessions, labs, exams, and grading criteria.

One-place Buffer: Monitor-based Implementation

Discusses the implementation of a one-place buffer using monitors in a concurrent environment.

Locks: Implementing Concurrency Mechanisms

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

Transitioning to Multithreaded Programming: Key Concepts

Covers the transition from single-threaded to multithreaded programming, focusing on memory models and consistency issues.

Actors: Evolution and Implementation

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

Locking Log in to Mediaspace to watch this video

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