With the rapid development of mobile Internet and the explosive growth of data volume, distributed systems are becoming more and more popular. In distributed systems, the problem of concurrent operations has become more and more prominent. When multiple threads request shared resources at the same time, these resources need to be locked to ensure data consistency. Distributed locks are one of the effective solutions for implementing concurrent operations in distributed systems. This article will introduce in detail how to use Redis to implement distributed locks.

1. Redis Basics

Redis is a memory-based key-value storage system that is widely used in distributed systems. As a high-performance NoSQL database, Redis has received widespread attention for its efficient read and write performance and rich data structures. Redis can implement distributed storage based on multiple machines and supports the following data structures:

• String (string)
• Hash (hash)
• List ( list)
• set(set)
• ordered set(sorted set)

The operations of Redis are based on these data structures, which are needed to implement distributed locks. A feature of Redis is used: SETNX (SET if Not eXists), that is, the value of the key can only be set when the specified key does not exist. If the key already exists, the SETNX operation returns failure.

2. Ideas of implementing distributed locks

To implement distributed locks, you first need to clarify the goal:

• In a distributed environment, When multiple threads request the same resource at the same time, ensure that only one thread can obtain the lock.
• If a thread has obtained the lock, other threads need to wait for the lock to be released.

In order to achieve the above goals, the following ideas can be adopted:

• Use the SETNX command of Redis to create a new key as the identification of the lock.
• If the SETNX command returns successfully, it means that the current thread has obtained the lock.
• Set the expiration time of the key to avoid deadlock.
• When a thread completes its task, the lock is released and the key is deleted.

3. Implementation code example

First, create a Redis connection:

import redis

conn = redis.Redis(host='localhost', port=6379, db=0)

Then, define the functions for acquiring and releasing locks:

def acquire_lock(conn, lockname, acquire_timeout=10, lock_timeout=10):
    identifier = str(uuid.uuid4())
    lockname = "lock:" + lockname
    end = time.time() + acquire_timeout
    while time.time() < end:
        if conn.setnx(lockname, identifier):
            conn.expire(lockname, lock_timeout)
            return identifier
        elif not conn.ttl(lockname):
            conn.expire(lockname, lock_timeout)
        time.sleep(0.001)
    return False

def release_lock(conn, lockname, identifier):
    pipe = conn.pipeline(True)
    lockname = "lock:" + lockname
    while True:
        try:
            pipe.watch(lockname)
            if pipe.get(lockname) == identifier:
                pipe.multi()
                pipe.delete(lockname)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False

Among them, the acquire_lock function is used to acquire the lock. The parameter description is as follows:

• conn: Redis connection.
• lockname: The name of the lock.
• acquire_timeout: The timeout when acquiring the lock, the default is 10 seconds.
• lock_timeout: The expiration time of the lock, the default is 10 seconds.

This function first generates a random identifier, then tries to acquire the lock every 0.001 seconds, and sets the expiration time. If the lock is not acquired within the specified timeout, False is returned.

The release_lock function is used to release the lock. The parameter description is as follows:

• conn: Redis connection.
• lockname: The name of the lock.
• identifier: The identifier returned when acquiring the lock.

This function first uses the WATCH command to monitor the lock. If the value of the lock is the same as the identifier, it uses the MULTI command to delete the lock and perform the operation. Otherwise, terminate monitoring and return False.

Finally, the distributed lock function can be realized using the acquire_lock and release_lock functions. The sample code is as follows:

import time
import uuid

def do_task():
    print("Task started...")
    time.sleep(5)
    print("Task finished")

def main():
    lockname = "mylock"
    identifier = acquire_lock(conn, lockname)
    if not identifier:
        print("Failed to obtain lock")
        return
    try:
        do_task()
    finally:
        release_lock(conn, lockname, identifier)

if __name__ == '__main__':
    main()

In this sample code, the acquire_lock function is used to acquire the lock, and the release_lock function is called to release the lock after executing the task.

4. Summary

Distributed lock is a technology widely used in distributed systems, which can effectively solve the problem of data consistency under concurrent operations. In this article, we introduce in detail how to use Redis to implement distributed locks. By using Redis's SETNX command and expiration time settings, as well as WATCH and MULTI commands, you can implement the distributed lock function.

The above is the detailed content of Detailed explanation of distributed lock implementation in Redis. For more information, please follow other related articles on the PHP Chinese website!