Home > Database > Redis > body text

Redis distributed lock implementation method

WBOY
Release: 2023-05-10 21:01:34
Original
5034 people have browsed it

Redis is an open source in-memory data caching system that can store and read data. In a distributed environment, when multiple applications operate on the same resource at the same time, problems with dirty data and data inconsistency may occur. In order to solve this problem, we can introduce distributed locks to ensure data consistency.

This article helps readers understand how to use Redis to implement distributed locks by introducing the application scenarios, principles and implementation methods of Redis distributed locks.

1. Application scenarios

In a distributed system, an application may need to operate multiple resources at the same time. So how to ensure that this application's operations on resources are thread-safe? At this time, distributed locks need to be introduced.

Distributed locks can be used to solve the following problems:

(1) Avoid multiple clients from modifying the same resource at the same time, resulting in data inconsistency.

(2) Prevent the client from making multiple modifications to the same resource due to network delays and other issues.

(3) Prevent the client from occupying resources for too long, causing other clients to be unable to access resources normally.

2. Principle

Redis distributed lock is mainly implemented through the setnx command. The setnx command is an atomic operation in Redis, which ensures that in concurrent operations of multiple clients, only one client can successfully set the key-value pair to Redis.

Next, let’s take a look at the specific implementation of Redis distributed lock.

3. Implementation method

(1) Obtain the lock

In the process of acquiring the lock, we need to use the setnx command to set a key-value pair. If the setting is successful, it means that we have obtained the lock. If the setting is unsuccessful, we need to wait for a period of time and try to obtain the lock again.

First, we obtain the lock through the following code block:

boolean lock = jedis.setnx(key, value) == 1;
Copy after login

Among them, key and value represent the name and value of the lock respectively, and jedis represents the Redis client.

If the name of the lock does not exist in Redis, then the return value of the above code is 1, indicating that the setting is successful and the lock is obtained. If the lock name already exists in Redis, the return value of the above code is 0, indicating that the setting failed and the lock acquisition failed.

(2) Release the lock

In the process of releasing the lock, we need to use the del command to delete the key-value pair in Redis.

First, we release the lock through the following code block:

long result = jedis.del(key);
Copy after login

Among them, key represents the name of the lock, and jedis represents the Redis client.

If the key-value pair in Redis is successfully deleted, the return value of the above code is 1, indicating that the lock is released successfully. If the key-value pair does not exist in Redis, the return value of the above code is 0, indicating that the lock release fails.

(3) Set the expiration time of the lock

In order to prevent the lock from being occupied all the time, we need to set the expiration time of the lock. When the lock holder does not release the lock within a certain period of time, Redis will automatically delete the lock to prevent the lock from being occupied forever.

First, we need to set the expiration time of the lock through the following code block:

jedis.expire(key, timeout);
Copy after login

Among them, key represents the name of the lock, and timeout represents the expiration time of the lock, in seconds.

In order to prevent accidentally deleting other clients' locks, you need to determine whether the value of the lock is consistent with the value you set when you acquired it.

String value = jedis.get(key);
if (StringUtils.isNotBlank(value) && value.equals(uuid)) {
  jedis.del(key);
}
Copy after login

Among them, uuid represents the unique identification of the client to obtain the lock.

(4) Prevent locks of other clients from being accidentally deleted

After using the lock, we need to release the lock correctly, otherwise the locks of other clients will be accidentally deleted.

Therefore, in order to prevent the locks of other clients from being accidentally deleted, we need to add a unique identifier to the code.

First, in the process of acquiring the lock, we need to generate a unique identifier for the client, as shown below:

String uuid = UUID.randomUUID().toString();
Copy after login

Then, in the process of acquiring the lock and releasing the lock, we need to Determine whether the value corresponding to the key is equal to the uuid to determine whether the lock is acquired by the current client. In the process of acquiring the lock and releasing the lock, the uuid needs to be set as the value to the value corresponding to the key.

The specific code is as follows:

boolean lock = jedis.setnx(key, uuid) == 1;
if (lock) {
  jedis.expire(key, timeout);
}

// 释放锁
String value = jedis.get(key);
if (StringUtils.isNotBlank(value) && value.equals(uuid)) {
  jedis.del(key);
}
Copy after login

(5) Wrong usage examples

In the process of using distributed locks, if we encounter the following situations, then Will cause deadlock:

// 获取锁
jedis.setnx(key, value);

// 不释放锁
Copy after login

Therefore, when using the lock, you must pay attention to releasing the lock correctly, otherwise it will bring unpredictable consequences to the system.

(6) Implementation class

Finally, let’s take a look at how to encapsulate the above code into a Redis distributed lock class.

import redis.clients.jedis.Jedis;

import java.util.UUID;

public class RedisLock {

    private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";

    private Jedis jedis;

    public RedisLock(Jedis jedis) {
        this.jedis = jedis;
    }

    /**
     * 尝试获取分布式锁
     * @param key 锁
     * @param requestId 请求标识
     * @param expireTime 超期时间(秒)
     * @return 是否获取成功
     */
    public boolean tryGetDistributedLock(String key, String requestId, int expireTime) {
        String result = jedis.set(key, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);
        return LOCK_SUCCESS.equals(result);
    }

    /**
     * 释放分布式锁
     * @param key 锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public boolean releaseDistributedLock(String key, String requestId) {
        String value = jedis.get(key);
        if (value != null && value.equals(requestId)) {
            jedis.del(key);
            return true;
        }
        return false;
    }

    /**
     * 获取请求标识
     * @return 请求标识
     */
    public static String getRequestId() {
        return UUID.randomUUID().toString();
    }

}
Copy after login

At this point, we have completed the implementation of Redis distributed lock.

4. Summary

This article helps readers understand how to use Redis to implement distributed locks by introducing the application scenarios, principles and implementation methods of Redis distributed locks. Since the implementation of distributed locks is relatively complex, we need to pay attention to some details, such as determining whether the value of the lock is consistent with the value set when acquiring it, and setting uuid as value to key during the process of acquiring and releasing the lock. The corresponding value is medium. Only by using distributed locks correctly can the consistency and reliability of data in a distributed system be ensured.

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

source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
About us Disclaimer Sitemap
php.cn:Public welfare online PHP training,Help PHP learners grow quickly!