Key Monitoring and Transactions with Redis in C++

Key Monitoring with `watch` in Redis using C++

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.

#include <iostream>
#include <hiredis/hiredis.h>
#include <string>

void updateBalance(redisContext* context, int user_id, int increment) {
    while (true) {
        redisReply* reply;

        // WATCH command
        reply = (redisReply*)redisCommand(context, "WATCH balance:%d", user_id);
        freeReplyObject(reply);

        // Get current balance
        reply = (redisReply*)redisCommand(context, "GET balance:%d", user_id);
        int balance = (reply->type == REDIS_REPLY_NIL) ? 0 : std::stoi(reply->str);
        freeReplyObject(reply);

        // MULTI command to start a transaction
        reply = (redisReply*)redisCommand(context, "MULTI");
        freeReplyObject(reply);

        // Set new balance
        reply = (redisReply*)redisCommand(context, "SET balance:%d %d", user_id, balance + increment);
        freeReplyObject(reply);

        // EXEC command to execute transaction
        reply = (redisReply*)redisCommand(context, "EXEC");

        if (reply->type == REDIS_REPLY_ARRAY && reply->elements == 1) {
            freeReplyObject(reply);
            break; // Transaction succeeded
        }

        std::cerr << "Retrying transaction due to an external modification." << std::endl;
        freeReplyObject(reply);
    }
}

int main() {
    // Connect to the Redis server
    redisContext* context = redisConnect("127.0.0.1", 6379);
    if (context == nullptr || context->err) {
        if (context) {
            std::cerr << "Connection error: " << context->errstr << std::endl;
        } else {
            std::cerr << "Connection error: can't allocate Redis context" << std::endl;
        }
        return 1;
    }

    // Set initial balance for user 1
    redisReply* reply = (redisReply*)redisCommand(context, "SET balance:1 100");
    freeReplyObject(reply);

    // Update balance for user 1
    updateBalance(context, 1, 50);

    // Retrieve updated balance
    reply = (redisReply*)redisCommand(context, "GET balance:1");
    if (reply->type == REDIS_REPLY_STRING) {
        std::cout << "Updated balance for user 1: " << reply->str << std::endl;
    } else {
        std::cerr << "Failed to retrieve the updated balance." << std::endl;
    }
    freeReplyObject(reply);

    // Free the context
    redisFree(context);

    return 0;
}

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.
Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal