Concurrency primitive
A concurrency primitive is a fundamental language or runtime mechanism for coordinating concurrent execution or controlling access to shared state or resources.
Grokking Simplicity
A synchronization construct that provides a defined operation for coordinating concurrent execution paths or managing shared resources.
- How it is used
- Uses reusable queues, cuts, and related tools to share resources safely and coordinate timelines.
- How deep it goes
- Builds queues, dropping queues, Cut, and JustOnce incrementally, including ordering analysis and JavaScript implementation details.
- Examples
- Demonstrates cart-total queues, dropping document saves, parallel web requests, completion barriers, and one-time text messages.
- What you can do after
- Build it from scratch, diagnose timing bugs with timeline diagrams, and refactor application-specific coordination into reusable primitives.
Read how Grokking Simplicity explains concurrency primitive →
Learn Concurrent Programming with Go
Classical concurrency primitives are low-level synchronization mechanisms traditionally used to coordinate concurrent execution.
- How it is used
- Coordinates concurrent executions through shared memory when low-level synchronization suits the problem.
- How deep it goes
- Explains mutexes, condition variables, and semaphores, then addresses scheduling, races, complexity, and implementation trade-offs.
- Examples
- Uses mutexes, condition variables, semaphores, waitgroups, channels, and shared-memory critical sections as concrete artifacts.
- What you can do after
- Builds synchronization tools from scratch and makes better-informed choices about when and how to use them.
Read how Learn Concurrent Programming with Go explains concurrency primitive →
Also covered in
- Robotics for ProgrammersIn early access (MEAP)
- Functional Programming in Scala, Second Edition
- Grokking Concurrency
- The Coder CafeIn early access (MEAP)
- Embedded Software with RustIn early access (MEAP)
- Writing for Developers: Blogs that get read
- Clojure: The Essential Reference
- 100 Go Mistakes and How to Avoid Them
What to know first
- lockingLocking is a synchronization technique that controls concurrent access to a shared resource or protected operation.
- threadA thread is a distinct sequence of execution with its own control flow and state, managed or scheduled by a processor, runtime, or operating system.
- ClojureClojure is a dynamically typed, functional Lisp-family programming language that runs primarily on the Java Virtual Machine and also supports other platforms.
- concurrencyConcurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
Related concepts
- actorincludes · An actor is a person, system, process, or computational entity that performs actions or participates in interactions within a system.
- *agent*includes · *agent* is a Clojure dynamic variable bound to the agent whose action function is currently executing.
- atomincludes · An atom is a Clojure reference type that supports synchronous, independent, coordinated updates to shared state without explicit locks.
- workflowincludes · A workflow is an organized sequence of coordinated activities or tasks through which work progresses toward a defined outcome.
- Clojure varincludes · A Clojure var is a named reference in a namespace that holds a root binding and may provide dynamically scoped bindings.
- mutexincludes · A mutex is a synchronization primitive that provides controlled exclusive access to shared data or a protected operation, admitting only one thread at a time.
Questions about concurrency primitive
What is concurrency primitive?
A concurrency primitive is a fundamental language or runtime mechanism for coordinating concurrent execution or controlling access to shared state or resources.
Which Manning books explain concurrency primitive?
Grokking Simplicity and Learn Concurrent Programming with Go.
What should I know before learning concurrency primitive?
Manning books that teach concurrency primitive usually introduce locking, thread, Clojure and concurrency first.
What kinds of concurrency primitive are there?
Kinds of concurrency primitive include actor, *agent*, atom, workflow, Clojure var and mutex.
What is concurrency primitive also called?
Concurrency primitive is also called synchronization primitive.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.

