Presents a solution to races and deadlocks based on a well-known deadlock-avoidance protocol and shows how it can be enforced by the compiler. It can be applied to programs in which the number of locks is fixed and known up front.

Explains why in the concurrent world, locality is a first-order issue that trumps most other performance considerations. Now locality is no longer just about fitting well into cache and RAM, but to avoid scalability busters by keeping tightly coupled ...

Looks at how lock-free programming avoids system failure by tolerating individual process failures.

A thread pool hides a lot of details, but to use it effectively some awareness of some things a pool does under the covers is needed to avoid inadvertently hitting performance and correctness pitfalls.

Explains how to use lock hierarchies to avoid deadlock by assigning each shared resource a level that corresponds to its architectural layer.

Motivates and illustrate best practices for using threads - techniques that will make concurrent code easier to write correctly and to reason about with confidence.

This article makes the case that a consistent mental model is needed to talk about concurrency.

Explains that deadlock can happen whenever there is a blocking (or waiting) cycle among concurrent tasks.

Explores lock-free code by focusing on creating a lock-free queue.

Sharing requires waiting and overhead, and is a natural enemy of scalability. This article focuses on one important case, namely mutable (writable) shared objects in memory, which are an inherent bottleneck to scalability on multicore systems.