How deeply does Elixir in Action, Third Edition cover locking?

Explains lock identity, acquisition, waiting, release, transactional wrapping, and registration internals without detailing broader failure handling.

Locking

As explained in Elixir in Action, Third Edition

A cluster-wide lock is a distributed mutual-exclusion mechanism that prevents competing operations on different nodes from proceeding simultaneously.

Mutual exclusion prevents competing operations on different nodes from proceeding simultaneously. In an Erlang cluster, :global provides arbitrarily named locks: after one process acquires a lock, no other process in the cluster can acquire it until release. section 12.1.5

A lock is identified by a resource term and a requester ID. Using the process ID as the requester normally limits ownership to one process. Acquisition communicates with other nodes; callers can wait indefinitely or configure a waiting limit. :global.trans/2 packages acquisition, execution, and release into one operation. section 12.1.5

Serialize work across two nodes

Acquire {:some_resource, self()} with :global.set_lock/1 on node1. A matching request on node2 waits until node1 calls :global.del_lock/1. For the acquire-release pattern, wrap the work with :global.trans/2.

Global registration uses the same mechanism internally: it locks the alias, checks whether it is already registered, informs all nodes, and releases the lock. This coordination creates inter-node message traffic, so locking is generally something to avoid when another design can provide the required behavior. section 12.1.3 section 12.1.5

How Elixir in Action, Third Edition covers it

Cover of Elixir in Action, Third Edition

liveBook manning.com

Read Elixir in Action, Third Edition on liveBook Get the book at manning.com

Also explained in

liveBook manning.com

Object-Oriented Software Design in C++Mutual exclusion is a synchronization property that restricts access to a protected resource so that only one thread can enter the critical operation at a time.
liveBook manning.com

Learn Go with Pocket-Sized ProjectsMutual exclusion is the property that prevents more than one execution context from accessing a protected resource at the same time.
liveBook manning.com

Modern C, Third EditionA mutex is a mutual-exclusion synchronization object that allows only one thread at a time to hold a protected critical section.
liveBook manning.com

Software Design for Python ProgrammersMutual exclusion is a synchronization constraint that permits only one thread or execution path at a time to access a protected resource or critical operation.
liveBook manning.com

LatencyA mutex lock is an exclusive synchronization primitive that permits only one concurrent execution context to access a protected resource at a time.
liveBook manning.com

100 Go Mistakes and How to Avoid ThemA mutex is a synchronization primitive that provides mutual exclusion by allowing at most one execution to enter a protected section at a time.
liveBook manning.com

Java Persistence with Spring Data and Hibernate epubLocking is a concurrency-control technique that restricts access to data while a transaction holds a lock on it.
liveBook manning.com

Modern CMutual exclusion is a synchronization property ensuring that at most one thread accesses a protected region at a time.
liveBook manning.com

Grokking ConcurrencyA lock is a synchronization mechanism that restricts access to a shared resource so that competing tasks cannot modify it simultaneously.
liveBook manning.com

PostgreSQL Mistakes and How to Avoid ThemA database lock is a concurrency control mechanism that permits or prevents access to a database object by other transactions.
liveBook manning.com

Advanced Algorithms and Data StructuresA lock is a synchronization primitive that coordinates access to shared resources by allowing mutually exclusive ownership.
liveBook manning.com

Go by Example
liveBook manning.com

Go in Practice, Second Edition
liveBook manning.com

ASP.NET Core in Action, 3eDatabase locking is a concurrency-control technique that restricts simultaneous access to shared database state.
liveBook manning.com

Go in Action, Second EditionA lock is a synchronization mechanism that restricts concurrent access to a protected resource.
liveBook manning.com

Terraform in Depth: Infrastructure as Code with Terraform and OpenTofuState locking is the coordination mechanism that prevents concurrent Terraform operations from modifying the same state simultaneously.
liveBook manning.com

Learn Rust in a Month of LunchesMutual exclusion is a concurrency property that allows at most one thread to access a protected resource at a time.

Compare how 18 books explain locking →

Related concepts

race conditionaddresses · A race condition is a concurrency defect in which program behavior or results depend on the relative timing or ordering of interacting operations.
condition variableused by · A condition variable is a synchronization object that allows threads to wait for a shared-state condition and be notified when it may have changed.
data raceaddresses · A data race is a concurrent access to shared data in which at least one access is a write and the accesses are not adequately synchronized.
shared resourceuses · A shared resource is data, an object, or another resource that multiple people, components, or execution contexts can access or use.
cnd_timedwaitused by · cnd_timedwait is a C threads-library function that atomically releases a mutex while waiting on a condition variable, then reacquires it after notification or an absolute timeout.
async/awaitcontrasts with · Async/await is language syntax for expressing asynchronous computations that suspend at awaited operations and resume when they can proceed without blocking the execution thread.

This explainer was generated by Manning's knowledge graph from the text of Elixir in Action, Third Edition. The section links point to the parts of the book it draws on.