Concurrent computing

Related lectures (31)

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

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

Threads: Concurrency and Parallelism in Computer Systems

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

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.

Asynchrony: Concepts and Implementations

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

Threads and Locks

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

Concurrency Primitives and Pitfalls

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

Multi-threaded Processors

Covers the basics of multi-threaded processors, including design, performance impact, and pipeline utilization.

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.

Understanding Simultaneous Multithreading in Modern Processors

Covers simultaneous multithreading, its implementation, and its impact on processor performance.

One place buffer: Producer-consumer queue

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

Reliable Storage: Regular Register Algorithm

Covers the specification of a register, sequential and concurrent execution, and correctness properties.

Memory Models: Visibility and Semantics

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

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.

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.