- Atomic vs. Non-Atomic Operations
- Atomic reference counting (with Zig code samples)
- Memory Barriers: a Hardware View for Software Hackers
- Memory Models: A Case For Rethinking Parallel Languages and Hardware
- Java Memory Model
- Foundations of the C++ Concurrency Memory Model
- Explanation of the Linux-Kernel Memory Consistency Model
- Memory Models by Russ Cox
- Repairing Sequential Consistency in C/C++11 + P0668R5: Revising the C++ memory model
- A Promising Semantics for Relaxed-Memory Concurrency
- Bounding Data Races in Space and Time + Multicore OCaml Memory model
- C++ Memory Ordering at Compile Time
- The Problem of Programming Language Concurrency Semantics
- Understandnig Atomics and Memory Ordering
- Weak memory concurrency in C/C++11
- Weak Memory Consistency
- Weakly Consistent Concurrency
- Memory Order in C++
- A Relaxed Guide to memory_order_relaxed - by Paul McKenney & Hans Boehm
- Futures and Promises
- Your Server as a Function, Systems Programming at Twitter, Finagle – Concurrent Programming with Futures
- Futures for C++11 at Facebook, Folly Futures,
- Zero-cost futures in Rust, Designing futures for Rust, RFC
- Fibers in C++: Understanding the basics
- Fibers, Oh My!
- Project Loom: Fibers and Continuations for the Java Virtual Machine
- State of Loom, Part 1, Part 2
- C++ / Distinguishing coroutines and fibers
- C++ / Fibers under the magnifying glass
- Lightweight concurrency in lua
- D - Fibers
- Coroutine Theory
- Writing custom C++20 coroutine systems
- Revisiting Coroutines by Ana Lúcia de Moura and Roberto Ierusalimschy
- Segmented Stacks in LLVM
- Rust / Abandoning segmented stacks in Rust
- Go / How Stacks are Handled in Go, Continious Stacks Design Doc
- Rust / Futures and Segmented Stacks
- Continuation Passing for C - A space-efficient implementation of concurrency
- C++ / call/cc (call-with-current-continuation): A low-level API for stackful context switching
- Making the Tokio scheduler 10x faster
- Rust / Work-Stealing Scheduler Discussion
- Scalable Go Scheduler Design Doc
- Dmitry Vyukov — Go scheduler: Implementing language with lightweight concurrency
- GopherCon 2020: Austin Clements - Pardon the Interruption: Loop Preemption in Go 1.14
- "Runtime scheduling: theory and reality" by Eben Freeman
- [Golang] Runtime
- [Rust] Tokio Multi-Threaded Runtime
- [Dlang] Phobos - Multiple Declarations
- [Kotlin] Coroutine Runtime
- [Scala] Cats Effect
- Go channels on steroids
- Scalable FIFO Channels for Programming via Communicating Sequential Processes
- Fast and Scalable Channels in Kotlin Coroutines
- Асинхронность в программировании
- Асинхронность: назад в будущее
- Kotlin Coroutines Proposal
- Zero-cost futures in Rust, Designing futures for Rust
- C#: Механика asnyc/await в C#
- Kotlin: Coroutines / Implementation details
- C++:
- What Color is Your Function?, Hacker news
- C#: Asynchrony in C# 5 Part Six: Whither async?
- Rust: A final proposal for await syntax, Await Syntax Write Up
- Kotlin: How do you color your functions?
- Zig: What is Zig's “Colorblind” Async/Await?
- Notes on structured concurrency, or: Go statement considered harmful
- Structured Concurrency Group, Resources
- Roman Elizarov – Structured concurrency
- Lewis Baker – Structured Concurrency: Writing Safer Concurrent Code with Coroutines and Algorithms
- Eric Niebler – Structured Concurrency
- Josua Wuyts - Tree-Structured Concurrency
- Sebastiaan Koppe - Structured Concurrency in D(Video)
- ThreadSanitizer – data race detection in practice, compiler-rt/lib/tsan/rtl
- FastTrack: Efficient and Precise Dynamic Race Detection
- Dynamic Partial-Order Reduction for Model Checking Software
- Finding and Reproducing Heisenbugs in Concurrent Programs
- CDSCHECKER: Checking Concurrent Data Structures Written with C/C++ Atomics
- How We Test Concurrent Primitives in Kotlin Coroutines
- Rust: Fearless Concurrency
- Pony: Reference capabilities
- C++: Clang Thread-Safety Analysis
- D: Fearless - Safe Concurrency in D
- Joe Duffy (Project Midori) – 15 Years of Concurrency
- Linearizability: A Correctness Condition for Concurrent Objects
- Consistency Models Map
- Linearizability versus Serializability
- Strong consistency models
- Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms
- A Scalable Lock-free Stack Algorithm
- The Baskets Queue
- Lock-free deques and doubly linked lists
- A Practical Multi-Word Compare-and-Swap Operation
- Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects
- Epoch-Based Memory Reclamation
- Differential Reference Counting
- Implementing a Lock-free
atomic_shared_ptr - folly /
AtomicSharedPtr - Automem Hands Free RAII in D
- Roman Elizarov — Lock-Free Algorithms for Kotlin Coroutines
- Lock-free структуры данных
- Zig's I/O and Concurrency Story by King Protty [Video]
- CppCon 2016 - "Elegant Asynchronous Code" by Nat Goodspeed [Video]
- Martin Kleppmann – Transactions: myths, surprises and opportunities, slides & references
- A Critique of ANSI SQL Isolation Levels
- Serializable Isolation for Snapshot Databases
- What Write Skew Looks Like
- A Read-Only Transaction Anomaly Under Snapshot Isolation
- Google Percolator
- Serializable Snapshot Isolation in PostgreSQL
- PostgreSQL SSI Implementation Notes
- A History of Transaction Histories
- An Introduction to Transaction Isolation Levels
- Correctness Anomalies Under Serializable Isolation
- Introduction to Consistency Levels
- Isolation levels vs. Consistency levels
- Maurice Herlihy – Transactional Memory, slides
- Gil Tene – Understanding Hardware Transactional Memory
- Is Parallel Programming Hard, And, If So, What Can You Do About It?, 17.3
- Глава 16 – Programming with Intel Transactional Synchronization Extensions
- Глава 15 – Intel TSX Recommendations
- TSX Anti-Patterns
- Lock Elision Implementation Guide
- [D] Software Transactional Memory in D (Video) by Brad Roberts
- [C++] CppCon 2015 - “Transactional Memory in Practice" by Brett Hall
- [Scala, ZIO] Introduction to Software Transactional Memory
- A (brief) retrospective on transactional memory by Joe Duffy
- Lord of io_uring
- A Universal I/O Abstraction for C++
- A Programmer-Friendly I/O Abstraction Over io_uring and kqueue
Author: Roman Lipovsky Original repository: from Gitlab - Awesome-Concurrency