SoFunction
Updated on 2025-03-04

Redis to achieve lock-up renewal project practice

Solution

When using Redis as storage for distributed locks, if a task needs to be executed for a long time and the lock expires during this period, a mechanism is needed to automatically extend the validity period of the lock, i.e. renewal. Generally speaking, the Redis lock renewal can be achieved in the following ways:

Renewal using Lua script

A common practice is to use Lua scripts to achieve renewal of locks. Redis supports the execution of Lua scripts on the server, which can be used to implement atomic operations. When a task starts executing, it sets a key in Redis (e.g.lock:resource_name) and set an initial expiration time (TTL). The task can then periodically try to update the expiration time of this key through the Lua script. If the key still exists and is not held by other nodes, it can be renewed successfully.

Automatic renewal and watchdog mechanism

Another way is to create a "watchdog" thread or timer that monitors the validity period of the lock and automatically extends its validity period before it is almost expiring. This mechanism requires careful handling to avoid attempts to renew the lock if it has been acquired by another node.

Using Redlock Algorithm

The Redlock algorithm is a distributed lock algorithm that can provide better consistency and availability guarantees. The algorithm recommends that each lock has a valid period and that the client should periodically try to renew the lock. If renewal fails (such as because of network partition), the client should check whether the lock is still held, and if not, it should not continue to perform sensitive operations.

Using Redisson Client

If you are using Java and want to simplify the management of distributed locks, consider using the Redisson client, which provides a high-level API to manage locks. Redisson's RLock can be automatically renewed until you explicitly call the unlock method or the application is closed.

Things to note

  • Reentry: Ensure that the lock is reentrant, i.e. the same holder can obtain the same lock multiple times.
  • Fairness: Ensure that the allocation of locks is fair, that is, the locks are allocated in the order requested.
  • Resource release: Make sure to release the lock when the task is over or an exception occurs to prevent deadlocks.
  • Final consistency: Make sure that even in exceptional circumstances, the lock will eventually be released correctly.

Use these strategies to help you effectively manage the expiration date of Redis locks when the task is not completed. However, when designing such a system, factors such as network latency and the availability of Redis instances need to be taken into account.

Code Example

Since different programming languages ​​have different implementation details, we will mainly use Python as an example to illustrate it here.

Solution 1: Use Lua script to achieve renewal

Lua script

First, we need to write a Lua script to achieve the renewal of the lock. This script needs to do two things:

  • Check if the lock still belongs to the current holder.
  • If so, the validity period of the lock will be extended; if not, no operation will be done.
local lockKey = KEYS[1]
local clientId = ARGV[1]
local newTimeout = tonumber(ARGV[2])

-- Check if the lock is held by the client
if ("get", lockKey) == clientId then
    -- Extend the lock timeout
    ("expire", lockKey, newTimeout)
end

Python code

Next is how to use the above Lua script in Python:

import redis
import time
from threading import Thread

def acquire_lock(redis_client, lock_key, client_id, timeout):
    return redis_client.set(lock_key, client_id, nx=True, ex=timeout)

def extend_lock(redis_client, lock_key, client_id, new_timeout):
    lua_script = """
    local lockKey = KEYS[1]
    local clientId = ARGV[1]
    local newTimeout = tonumber(ARGV[2])

    if ("get", lockKey) == clientId then
        ("expire", lockKey, newTimeout)
    end
    """
    # Execute Lua scripts using EVAL    return redis_client.eval(lua_script, 1, lock_key, client_id, new_timeout)

def renew_lock(redis_client, lock_key, client_id, initial_timeout, renew_interval):
    while True:
        # Try renewing the lock        extend_lock(redis_client, lock_key, client_id, initial_timeout)
        (renew_interval)

def main():
    redis_client = (host='localhost', port=6379, db=0)
    lock_key = "lock:example"
    client_id = "client1"
    initial_timeout = 60  # Initial lock timeout    renew_interval = 15   #Continued interval
    # Obtain the lock    if acquire_lock(redis_client, lock_key, client_id, initial_timeout):
        print(f"Client {client_id} acquired the lock.")
        
        # Start renewal thread        renew_thread = Thread(target=renew_lock, args=(redis_client, lock_key, client_id, initial_timeout, renew_interval))
        renew_thread.start()

        # Execute long-running tasks        try:
            do_long_running_task()
        finally:
            # Release the lock after the task is completed            release_lock(redis_client, lock_key, client_id)
            renew_thread.join()  # Wait for the renewal thread to end    else:
        print(f"Client {client_id} failed to acquire the lock.")

def release_lock(redis_client, lock_key, client_id):
    if redis_client.get(lock_key) == client_id:
        redis_client.delete(lock_key)

def do_long_running_task():
    # Simulate long-running tasks    (120)
    print("Long running task completed.")

if __name__ == '__main__':
    main()

Solution 2: Use Redlock algorithm

The Redlock algorithm involves multiple Redis instances to reduce the impact of a single point of failure. We will not discuss its implementation in detail here, as more complex network and synchronization issues are involved.

Solution 3: Use Redisson Client

Redisson is a Java client that provides advanced features such as automatic renewal locks. Since this is a Java library, no Python examples are provided here. If you use Java, you can directly use the RLock class provided by Redisson to simplify lock management.

This is the end of this article about the project practice of Redis to achieve lock renewal. For more related Redis lock renewal content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!