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

Lecture

Concurrency: Deadlock

Related lectures (33)

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.

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 Basics: Threads and Synchronization

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

Parallel Programming: Fundamentals

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

Concurrency and Parallelism: Queue

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

Threads and Locks

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

Memory Models: Visibility and Semantics

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

Principles of Parallelism

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

Concurrency and Parallelism: Visibility

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

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.

Atomic execution: Synchronization in threads

Covers atomic execution in threads, race conditions, shared variables, and synchronized blocks.

Atomic Operations: Basics and Applications

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

Sequential consistency: Basic Concepts

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

Concurrency with Futures

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

Actors: Evolution and Implementation

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

Readers-writer Lock

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

Concurrency: Volatile

Explores volatile variables in Java for concurrent programming and synchronization importance.

Threads: Introduction and Implementation

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

Introduction to Concurrency

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