Concurrency Control

Concurrency control is an essential aspect of any database management system (DBMS), ensuring that transactions are executed simultaneously without leading to inconsistencies in the database. In a concurrent environment, multiple transactions are allowed to run simultaneously to maximize system resources and improve performance. However, without proper management, concurrent transactions could interact in a way that compromises data integrity.

Concurrency control, then, is a strategy that manages simultaneous transactions while preserving ACID (Atomicity, Consistency, Isolation, Durability) properties. It protects the database from problems like dirty reads, non-repeatable reads, phantom reads, and other data anomalies. Various techniques can be implemented to control concurrency such as two-phase locking, timestamp ordering, and optimistic concurrency control, among others.

Concurrency Control in Polypheny

Polypheny uses strong strict two-phase locking (SS2PL) to manage simultaneous transactions. Two-phase locking is a protocol that guarantees serializability of transactions in a concurrent system. It works in two stages: the growing phase, where a transaction may acquire locks but not release any, and the shrinking phase, where a transaction may release locks but not acquire any new ones.

The ‘strong strict’ variant of two-phase locking ensures that exclusive locks (write locks) held by a transaction are not released until the transaction commits or aborts, thereby preventing any other transaction from reading uncommitted data (dirty reads) or overwriting data that could potentially be rolled back.

In Polypheny, the locks are applied at an entity level. This means that the locks are placed on entire entities, such as tables or collections, rather than individual records or attributes. This method of locking can increase efficiency and simplicity, especially in environments with fewer conflicts. However, it should be noted that entity-level locking could also lead to unnecessary waiting if two transactions need to access different records in the same entity.

More fine-grained concurrency control mechanisms will be introduced in a future version of Polypheny. Stay tuned!

How to Use Concurrency Control in Polypheny

When working with Polypheny, you don’t need to manually apply locks to the entities. The system automatically manages the locking and unlocking processes. However, it’s crucial to design your transactions with the understanding that the DBMS uses SS2PL.

  • Keep Transactions Short: Try to design your transactions to be as short as possible to reduce the time locks are held. Longer transactions could increase the waiting time for other transactions, potentially leading to deadlocks.

  • Commit Transactions Frequently: Committing transactions frequently can free up locks and allow other transactions to proceed. However, be aware that committing a transaction makes its changes permanent. Therefore, ensure that the data is in a consistent state before committing.

  • Access Data in a Consistent Order: Accessing data in a consistent order across different transactions can help avoid deadlocks.


A deadlock is a situation that occurs in a concurrent system when two or more transactions indefinitely wait for each other to release resources. Essentially, a deadlock creates a cycle of dependencies where each transaction is holding a resource another transaction needs, and vice versa, with none able to proceed.

For instance, consider two transactions, T1 and T2. If T1 holds a lock on resource A and needs a lock on resource B to continue, and T2 holds a lock on resource B and needs a lock on resource A to proceed, a deadlock occurs. Both transactions are stuck, waiting for a resource that will never become available.

Deadlocks are problematic because they lead to a halt in system execution, and the involved transactions remain uncompleted. Therefore, identifying and handling deadlocks are crucial for the smooth operation of any database system.

Polypheny is designed to automatically detect and resolve deadlocks. The detection mechanism identifies cycles of dependencies and breaks them by selecting one transaction to abort. The transaction that is chosen to be aborted is typically the one that will incur the least cost to roll back. Once this transaction is aborted, it releases its locks, allowing the other transaction(s) to proceed. The aborted transaction’s changes are rolled back, and it can be restarted later.

In case you are experiencing frequent deadlocks, consider revising your transaction design. Ensuring that transactions access data in a consistent order can help prevent the circular wait condition and hence reduce the likelihood of deadlocks. Also, keeping transactions as short as possible and committing transactions frequently can significantly minimize the occurrence of deadlocks.

© Polypheny GmbH. All Rights Reserved.