Conditional Transactions with WATCH

In the previous lesson, we explored the basics of Redis Transactions and how they ensure atomic execution of commands. Now, we’ll enhance our understanding by diving into conditional transactions using the WATCH command. This feature allows us to monitor keys for changes before executing a transaction, ensuring data consistency in concurrent environments.

By the end of this lesson, you’ll be able to implement transactions that handle key conflicts effectively.

Conditional transactions in Redis use the WATCH command to monitor specific keys for changes. If any watched key is modified by another client before the transaction is executed, the transaction will abort. This is especially useful in high-concurrency scenarios where multiple clients may access the same data.

Key features of conditional transactions include:

• Conflict Detection: Monitors keys for changes and aborts the transaction if they are modified.
• Ensured Consistency: Guarantees that updates are based on the latest state of data.
• Retry Mechanism: Allows applications to handle failed transactions gracefully and retry as needed.

Using WATCH, you can implement robust solutions to prevent race conditions and maintain data integrity.

Let’s walk through an example of safely updating a user’s balance using the WATCH command. Our goal is to ensure no other client modifies the balance while our transaction is in progress.

This implementation consists of two main parts: monitoring and updating the balance.

To safely update a user’s balance, the key must be monitored and commands queued appropriately.

public static void updateBalance(Jedis jedis, String userId, int increment) {
    while (true) {
        try {
            // Watch the balance key for changes
            jedis.watch("balance:" + userId);

            // Retrieve the current balance
            String balanceStr = jedis.get("balance:" + userId);
            int balance = balanceStr != null ? Integer.parseInt(balanceStr) : 0;

            // Start a transaction
            Transaction transaction = jedis.multi();
            transaction.set("balance:" + userId, String.valueOf(balance + increment));

In this section:

• The WATCH command monitors the key balance:<userId> for changes. If any other client modifies this key, the transaction will abort.
• The GET command fetches the current balance. If no value exists, it defaults to 0.
• A transaction is started using multi(), and the SET command to update the balance is queued.

This process sets the stage for executing a transaction by ensuring that updates are based on the most recent data, safeguarding against race conditions.