Question: How does locking work in a PostgreSQL cluster?


Locking is a fundamental aspect of managing data integrity and concurrency in database systems, including PostgreSQL clusters. In PostgreSQL, locks are used to manage access to database objects like tables, rows, etc., to ensure that transactions occur smoothly without conflicting with one another.

Types of Locks in PostgreSQL

PostgreSQL implements several types of locks:

  1. ROW LEVEL LOCKS: These locks are acquired on individual rows rather than entire tables.

    • FOR UPDATE: Locks the row to prepare for an update.
    • FOR NO KEY UPDATE: Similar to FOR UPDATE, but less restrictive on replicas.
    • FOR SHARE: Allows others to read the row but prevents deletion or edits.
    • FOR KEY SHARE: The least restrictive, allowing both reads and writes but preventing changes that would affect primary key columns.
  2. TABLE LEVEL LOCKS: These can lock whole tables in various modes, ranging from restricting writes (SHARE mode) to blocking all other accesses (EXCLUSIVE mode).

  3. ADVISORY LOCKS: These are locks that the application can acquire and release manually. They're not tied to any particular table or row and are useful for coordinating operations between different parts of an application.

Lock Management in PostgreSQL Clusters

In a PostgreSQL cluster, comprising multiple nodes (primary and replicas), locks are crucial for maintaining consistency across nodes. Here’s how it generally works:

  • Primary Node: This node accepts write operations. When a transaction modifies data, it acquires locks at the necessary level (row, table, etc.). These locks must be held until the transaction commits or rolls back, ensuring consistent data state during concurrent operations.

  • Replica Nodes: These nodes receive data changes from the primary node through replication. Logical replication allows replica nodes to apply incoming changes in a transactionally consistent manner, requiring row-level locks as they apply changes.

Example: Row-Level Locking

Assuming you have a table called employees and want to update an employee's data safely, you might use a transaction with row-level locking:

BEGIN; SELECT * FROM employees WHERE id = 1 FOR UPDATE; UPDATE employees SET salary = salary + 1000 WHERE id = 1; COMMIT;

This SQL snippet starts a transaction, selects the employee with id = 1 with an exclusive lock, increments their salary, and then commits the transaction. During this transaction, other transactions will be prevented from making conflicting changes to this row.


Efficient use of locks in PostgreSQL, especially within clustered environments, is vital for maintaining data integrity and performance. Understanding the different types of locks and their proper application can help prevent deadlocks and improve the responsiveness of your database system.

Was this content helpful?

White Paper

Free System Design on AWS E-Book

Download this early release of O'Reilly's latest cloud infrastructure e-book: System Design on AWS.

Free System Design on AWS E-Book
Start building today

Dragonfly is fully compatible with the Redis ecosystem and requires no code changes to implement.