Welcome back! Previously, you learned how to build and execute basic transactions in Redis using pipelines in C++. In this lesson, we are going a step further by introducing the concept of monitoring keys to control transaction execution. This approach is essential for scenarios where you need to ensure operations are completed only when specific conditions are met.

Let's take a look at how you can implement key monitoring alongside transaction handling in your code using hiredis.

Here are detailed explanations for the key Redis commands used for transactions and key monitoring:

1. WATCH Command:

   • Purpose: Monitors one or more keys (balance:<user_id>) for changes before starting a transaction.
   • Operation: Alerts the client if changes occur to the keys by another Redis command, which invalidates the current transaction when EXEC is called.
   • In this code, it means keeping an eye on balance:1 to ensure no other client modifies it while you prepare a transaction.
   • Why It's Needed: The WATCH command is crucial for maintaining data consistency and integrity when multiple clients interact with Redis concurrently. By watching a key, we can prevent race conditions where the key's value might be altered by others right before executing the transaction, leading to errors or incorrect results. This ensures that transactional logic operates on the most current data.

2. MULTI Command:

   • Purpose: Marks the start of a Redis transaction.
   • Operation: Begins queuing subsequent commands as part of a transaction rather than executing them immediately.
   • Sets the stage for atomic execution—either all commands within the transaction block are applied, or none are if conditions change (e.g., watched keys are modified).

3. EXEC Command:

   • Purpose: Attempts to execute all queued commands in the transaction.
   • Operation: Ensures atomicity; if watched keys were changed, EXEC will return nil, meaning the transaction didn't happen.
   • In this lesson, it enforces that the balance update happens only if no other client changed balance:<user_id> since WATCH.

• Atomicity means all operations within a transaction are completed successfully or none at all. This property prevents inconsistencies that may arise from partial updates.
• For instance, in our code, if another client updates the balance while our transaction is pending, the entire operation will abort, ensuring we don't apply changes on outdated data. The updateBalance function keeps retrying until the transaction is successfully applied without other interferences.

In this lesson, you learned how to monitor a key with the watch command in Redis using hiredis in C++. The above code ensures that if another client modifies the key being monitored, the transaction is retried until it successfully updates the balance.

Ready to explore further? In the next section, you'll practice building pipelines to execute and retrieve results efficiently in C++, enhancing your understanding of Redis pipelines in real-world applications.