Optimistic concurrency control

API Design

Meaning

Optimistic concurrency control (OCC) is a strategy where concurrent transactions proceed without acquiring locks, then verify at commit time that no other transaction has modified the same data, typically using version numbers or timestamps. It addresses the throughput bottleneck that pessimistic locking creates in low-contention workloads where conflicts are rare. Triggered when designing systems with concurrent writers where blocking would be wasteful but data integrity must still be preserved.

Primary Function

Concurrency control

Communicative Purpose

Prevents lost updates and write conflicts without holding locks, enabling higher throughput in low-contention scenarios.

Pattern

read entity with version → modify locally → write with version check → retry on conflict

Função primária

Concurrency control

Propósito comunicativo

Prevents lost updates and write conflicts without holding locks, enabling higher throughput in low-contention scenarios.

Situações de gatilho

Database design: handling concurrent updates to the same row in high-throughput web applications

Contextos

Distributed systems: coordinating writes across replicas without distributed lock services

Padrão

read entity with version → modify locally → write with version check → retry on conflict

Colocados típicos

version number
timestamp
ETag
compare-and-swap
retry loop
transaction isolation level
conflict detection

Substituições comuns

Pessimistic locking (guaranteed but blocks readers)
MVCC (snapshot isolation
more complex)
last-writer-wins (simpler but silently loses updates)

Erros comuns

Assuming OCC prevents all conflicts: it only detects them at commit time, not during reads — cause: confusing detection with prevention; consequence: data corruption if retry logic is missing

Similar / contraste

Pessimistic locking: blocks readers/writers preemptively rather than detecting conflicts after the fact

Interferências

Coming from single-threaded environments: may assume writes are atomic — OCC requires explicit version tracking across concurrent operations

Família do chunk

pessimistic locking
MVCC
compare-and-swap
transaction isolation levels
conflict resolution

Nuance

When NOT to use: high-contention workloads where conflicts are frequent, causing retry storms and starvation

Efeito pragmático

Enables high-throughput concurrent writes in distributed systems without distributed lock services, reducing latency and avoiding lock-related deadlocks.

Dica de memória

Optimistic concurrency control: like editing a shared Google Doc — everyone works on their own copy, then the system merges changes and asks you to retry if someone else edited the same paragraph.

Upgrade path

Multi-version concurrency control (MVCC), distributed consensus protocols (Paxos, Raft)

Frequência: MediumFormulaicidade: FlexiblePrioridade de aquisição: Recognition firstTag de espaçamento: Medium-term

Examples

from sqlalchemy import Column, Integer, String from sqlalchemy.orm import declarative_base, Session from sqlalchemy.exc import StaleDataError Base = declarative_base() class Account(Base): __tablename__ = 'accounts' id = Column(Integer, primary_key=True) name = Column(String) balance = Column(Integer) version_id = Column(Integer, default=0) session = Session() account = session.query(Account).filter_by(id=1).one() original_balance = account.balance original_version = account.version_id account.balance = original_balance - 100 try: session.commit() except StaleDataError: session.rollback() refreshed = session.query(Account).filter_by(id=1).one() refreshed.balance = refreshed.balance - 100 session.commit()

import requests response = requests.get('https://api.example.com/documents/42') etag = response.headers['ETag'] current_content = response.json() updated_content = {**current_content, 'title': 'Revised Title'} result = requests.put( 'https://api.example.com/documents/42', json=updated_content, headers={'If-Match': etag} ) if result.status_code == 412: refreshed = requests.get('https://api.example.com/documents/42') new_etag = refreshed.headers['ETag'] retry_payload = {**refreshed.json(), 'title': 'Revised Title'} requests.put( 'https://api.example.com/documents/42', json=retry_payload, headers={'If-Match': new_etag} )

import jakarta.persistence.*; @Entity public class Product { @Id private Long id; private String name; private int stock; @Version private long version; public void decrementStock(int quantity) { if (stock < quantity) { throw new IllegalStateException("Insufficient stock"); } stock -= quantity; } } // Usage EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); Product product = em.find(Product.class, 1L); product.decrementStock(5); try { em.getTransaction().commit(); } catch (OptimisticLockException conflict) { em.getTransaction().rollback(); // Retry: re-read and reapply }