Concurrency Control in Distributed Systems

When two or more processes reach for the same shared resource at the same moment, something has to give. In a single booking system, that resource might be a seat, a bank balance, or an inventory count — and the failure mode, a race condition, is the same shape regardless of the domain.

The goal of concurrency control is to keep data correct — one seat, one occupant — without slowing every request down to a crawl. The challenge is that in a distributed, microservices world, the tools that solved this problem on a single machine no longer apply.

02Why local locking fails

The instinct, coming from single-process programming, is to reach for a language-level lock:

// This does NOT protect you in a distributed system
public synchronized void bookSeat(int seatId) {
    // only safe within ONE JVM instance
}

synchronized protects one process's memory. It says nothing about a second instance of the same service running on a different machine, which is the normal case the moment you scale past one replica.

03Database fundamentals

Transactions and ACID

A transaction bundles several operations into one unit: either all of them apply, or none do. The classic example is moving money between two accounts:

BEGIN TRANSACTION;
    UPDATE accounts SET balance = balance - 500 WHERE id = 1; -- debit
    UPDATE accounts SET balance = balance + 500 WHERE id = 2; -- credit
    -- if anything fails, ROLLBACK returns the DB to its prior state
COMMIT;

If the credit fails partway through, the debit is rolled back with it — the account holder never simply loses $500 to a crashed process.

Two kinds of locks

Underneath isolation, a database is choosing between two lock flavors on every row it touches:

04Isolation levels

Isolation levels are a dial between correctness and throughput. Turning it up prevents more anomalies; turning it down lets more transactions run at once.

Three ways a read can go wrong

(Media convention above: red marks a fully unsafe read; amber marks an anomaly that's narrower but still real.)

Higher isolation isn't free — Serializable typically means range locks and lower throughput. Pick the lowest level that still keeps your invariants true.

05Distributed concurrency techniques

With the primitives in place, there are two coherent philosophies for handling a write in a distributed system: assume conflicts are rare, or assume they're common.

A. Optimistic concurrency control (OCC)

Philosophy: don't lock — do the work, then check nothing changed before committing.

CREATE TABLE seats (
    id INT PRIMARY KEY,
    status VARCHAR(20),
    version INT DEFAULT 0    -- the key column
);

@Entity
public class Seat {
    @Id
    private Long id;
    private String status;

    @Version
    private Integer version;
}

@Transactional
public boolean bookSeat(Long seatId) {
    try {
        Seat seat = seatRepository.findById(seatId)
                .orElseThrow(() -> new RuntimeException("Seat not found"));
        if (!"available".equals(seat.getStatus())) return false;

        seat.setStatus("booked");
        seatRepository.save(seat);   // JPA checks version automatically
        return true;
    } catch (OptimisticLockingFailureException e) {
        return false; // caller decides whether to retry
    }
}

String sql = """
    UPDATE seats
    SET status = 'booked', version = version + 1
    WHERE id = ? AND version = ? AND status = 'available'
""";
int rowsUpdated = jdbcTemplate.update(sql, seatId, expectedVersion);
return rowsUpdated == 1; // 0 means someone beat you to it

B. Pessimistic concurrency control (PCC)

Philosophy: conflicts are likely — take the lock first, then do the work with nobody else able to interfere.

@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("SELECT s FROM Seat s WHERE s.id = :id")
Optional<Seat> findByIdWithLock(@Param("id") Long id);

@Transactional
public boolean bookSeat(Long seatId) {
    Seat seat = seatRepository.findByIdWithLock(seatId)
            .orElseThrow(() -> new RuntimeException("Seat not found"));
    if (!"available".equals(seat.getStatus())) return false;

    seat.setStatus("booked");
    seatRepository.save(seat);
    return true; // lock released on commit
}

try {
    bookSeat(seatId);
} catch (DeadlockLoserDataAccessException e) {
    retryBookSeat(seatId);
}

06Choosing a strategy

07Quick reference