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

Lecture

Concurrency and Mutual Exclusion

Description

This lecture covers the importance of concurrency and parallelism, the need for atomic operations, and the implementation of locks for mutual exclusion in critical sections. It discusses the issues with threads, the use of interruptible locks, spin locks, and hardware-supported mechanisms like Test-and-Set and Compare-and-Swap. The lecture emphasizes the significance of ensuring atomicity through mutual exclusion to prevent data races and achieve correct program execution.

This video is available exclusively on Mediaspace for a restricted audience. Please log in to MediaSpace to access it if you have the necessary permissions.

Watch on Mediaspace

Official source

Ontological neighbourhood

Computer engineering

High-performance computing: Parallel computing

Related concepts (32)

Lock (computer science)

In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive: a mechanism that enforces limits on access to a resource when there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy, and with a variety of possible methods there exists multiple unique implementations for different applications. Generally, locks are advisory locks, where each thread cooperates by acquiring the lock before accessing the corresponding data.

Spinlock

In software engineering, a spinlock is a lock that causes a thread trying to acquire it to simply wait in a loop ("spin") while repeatedly checking whether the lock is available. Since the thread remains active but is not performing a useful task, the use of such a lock is a kind of busy waiting. Once acquired, spinlocks will usually be held until they are explicitly released, although in some implementations they may be automatically released if the thread being waited on (the one that holds the lock) blocks or "goes to sleep".

Mutual exclusion

In computer science, mutual exclusion is a property of concurrency control, which is instituted for the purpose of preventing race conditions. It is the requirement that one thread of execution never enters a critical section while a concurrent thread of execution is already accessing said critical section, which refers to an interval of time during which a thread of execution accesses a shared resource or shared memory.

Critical section

In concurrent programming, concurrent accesses to shared resources can lead to unexpected or erroneous behavior, so parts of the program where the shared resource is accessed need to be protected in ways that avoid the concurrent access. One way to do so is known as a critical section or critical region. This protected section cannot be entered by more than one process or thread at a time; others are suspended until the first leaves the critical section.

Linearizability

In concurrent programming, an operation (or set of operations) is linearizable if it consists of an ordered list of invocation and response events, that may be extended by adding response events such that: The extended list can be re-expressed as a sequential history (is serializable). That sequential history is a subset of the original unextended list. Informally, this means that the unmodified list of events is linearizable if and only if its invocations were serializable, but some of the responses of the serial schedule have yet to return.

Related lectures (42)

Monitors: Synchronization and Cooperation

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

Readers-writer Lock

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

Concurrency Properties: Basics and Locks

Explores concurrency properties, race conditions, and the basics of locks.

Atomic Operations: Basics and Applications

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

Concurrency Basics: Threads and Synchronization