Learn how to implement distributed locks in redis - my own understanding

One 、 Import maven rely on <!– operation redis Of java client jedis –> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> Two 、 Code implementation import java.util.UUID;

import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool;

/** * The idea of distributed locking ： Multiple server clusters , Only one of them is allowed jvm To operate * redis The idea of implementing distributed lock : * * Get the lock : In more than one jvm Under the circumstances ,redis Realize distributed lock passing setnx Method to create the same key , * This key Is the only one that does not repeat , If the deposit is successful, return 1 Get the lock , Failure to deposit returns 0,value Use a unique non repeating random number as the thread's ID. * * Release the lock : In order to guarantee the lock acquired by the thread , The lock released is the same , In the delete reids Of key When , To ID Judge , Is the same ID Before deleting * * How to prevent deadlock * 1. Set a time period before acquiring a lock , If the thread has not acquired the lock in this time period , Then the thread will give up acquiring the lock , return null * 2. Also set another time period , After the thread obtains the lock , Yes key Set the effective time , After this is the time period ,key Automatically delete , Release the lock Return thread ID * * @author zxlovey * */ public class LockRedis { // jedis Thread pool private JedisPool jedisPool;

public LockRedis(JedisPool jedisPool) { this.jedisPool = jedisPool; }

private String reidsKey = “redis_key”;

// Get the lock /** * * @param acquireTimeout * A period of time before a lock is acquired * @param timeOut * After the thread gets the lock , Yes key Set the effective time Usually in seconds */ public String getLockRedis(Long acquireTimeout, Long timeOut) { Jedis conn = null; try { // Get jedis conn = jedisPool.getResource();

Long endTime = System.currentTimeMillis() + acquireTimeout; int expireLock = (int) (timeOut / 1000);

String identifierValue = UUID.randomUUID().toString();

while (System.currentTimeMillis() < endTime) { if (conn.setnx(reidsKey, identifierValue) == 1) { // Get the lock Set the effective time conn.expire(reidsKey, expireLock); // return value, This value As thread id When releasing the lock, you need to judge the deleted key It is the same as the acquired lock return identifierValue; } }

} catch (Exception e) { // TODO: handle exception } finally { if (conn != null) { conn.close(); } }

return null; }

// Release the lock /** * * @param identifierValue * The lock ID, Namely key Corresponding value */ public void unLockRedis(String identifierValue) { Jedis conn = null; try { conn = jedisPool.getResource();

if (conn.get(reidsKey).equals(identifierValue)) { // Acquired key Of value identical , Description is the lock resource of the same thread // Delete key conn.del(reidsKey); System.out.println(“ Lock release successful :” + Thread.currentThread().getName() + “— The lock ID:” + identifierValue); }

} catch (Exception e) {

} finally { if (conn != null) { conn.close(); } } }

}

import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig;

public class LockServer { private static JedisPool pool = null;

static { JedisPoolConfig config = new JedisPoolConfig(); // Set the maximum number of connections config.setMaxTotal(200); // Set the maximum number of idle config.setMaxIdle(8); // Set the maximum waiting time config.setMaxWaitMillis(1000 * 100); // stay borrow One jedis When an instance , Is it necessary to verify , if true, Then all jedis Instances are available config.setTestOnBorrow(true); pool = new JedisPool(config, “127.0.0.1”, 6379, 3000); } private LockRedis lockRedis = new LockRedis(pool); // demonstration redis Implement distributed locks public void seckill() { //1. Get lock String identifierValue = lockRedis.getLockRedis(1000L, 1000L); if(identifierValue == null){ System.out.println(“ Lock acquisition failed :”+Thread.currentThread().getName()+”; The reason for the failure is that the time to acquire the lock timed out ”); return; } System.out.println(“ Lock acquired successfully :”+Thread.currentThread().getName()+”— The lock ID：”+identifierValue); //2. Release the lock lockRedis.unLockRedis(identifierValue); } }

public class ThreadLock extends Thread{ private LockServer lockServer; public ThreadLock(LockServer lockServer) { this.lockServer = lockServer; } @Override public void run() { lockServer.seckill(); } }

public class Test001 { public static void main(String[] args) { LockServer lockServer = new LockServer(); for (int i = 0; i < 500; i++) { ThreadLock tl = new ThreadLock(lockServer); tl.start(); } } }

Publisher ： Full stack programmer stack length , Reprint please indicate the source ：https://javaforall.cn/100803.html Link to the original text ：https://javaforall.cn