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

Concurrent computing

Related lectures (31)

Concurrency with Futures

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

Asynchronous Programming with Futures

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

Threads: Introduction and Implementation

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

Asynchronous Programming: Callbacks and Failures

Covers the concept of asynchronous programming and how to handle dependencies and failures.

Message Processing Semantics

Explores the principles of reactive programming and message processing semantics in Akka, emphasizing actor encapsulation, reliable messaging, and message delivery guarantees.

The Actor Model: Principles of Reactive Programming

Covers the Actor Model, emphasizing asynchronous message passing and changing an Actor's behavior.

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 and Locks

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

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: Deadlock

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

One place buffer: Producer-consumer queue

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

Memory Models: Visibility and Semantics

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

Reactive Programming: Scalability

Covers the principles of reactive programming with a focus on scalability and various routing strategies.

The Actor Model: Principles of Reactive Programming

Introduces the Actor Model, explaining actors' identity, behavior, and asynchronous message passing.

Dining philosopher problem

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

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 in Python Programming

Covers Python basics, threading, shared data issues, and deadlock prevention.

Threads: Concurrency and Parallelism in Computer Systems Log in to Mediaspace to watch this video

Covers the thread abstraction in computer systems, focusing on concurrency, parallelism, and the management of threads using the POSIX API.

Asynchrony: Concepts and Implementations Log in to Mediaspace to watch this video

Covers the concepts and implementations of asynchrony, including synchronous and asynchronous code, OS threads, and writing asynchronous code in Java.