How to use redis to implement distributed locks

Use Redis to implement distributed locks

redis feature introduction

1. Support rich data types, such as String, List, Map , Set, ZSet, etc.

2. Support data persistence, both RDB and AOF methods

3. Support cluster working mode, strong partition fault tolerance

4. Single thread, sequential processing of commands

5. Support transactions

6. Support publication and subscription

Redis implements distributed locks using the SETNX command:

SETNX key value

Set the value of key to value if and only if key does not exist.

If the given key already exists, SETNX will not take any action.

SETNX is the abbreviation of "SET if Not eXists" (if it does not exist, then SET).

Available versions: >= 1.0.0 Time complexity: O(1) Return value:

Set successfully, return 1.

Failed to set, return 0.

redis> EXISTS job                # job 不存在
(integer) 0

redis> SETNX job "programmer"    # job 设置成功
(integer) 1

redis> SETNX job "code-farmer"   # 尝试覆盖 job ，失败
(integer) 0

redis> GET job                   # 没有被覆盖
"programmer"

First, we need to encapsulate a public Redis access tool class. This class needs to inject RedisTemplate instances and ValueOperations instances. ValueOperations instances are used because the distributed lock implemented by Redis uses the simplest String type. In addition, we need to encapsulate three methods, namely setIfObsent (String key, String value), expire (String key, long timeout, TimeUnit unit), and delete (String key), which correspond to the SETNX, expire, and del commands of Redis respectively. The following is the specific implementation of the Redis access tool class:

@Component
public class RedisDao {

	@Autowired
	private RedisTemplate redisTemplate;
	
	@Resource(name="redisTemplate")
	private ValueOperations<Object, Object> valOpsObj;
	
	/**
	 * 如果key不存在，就存储一个key-value，相当于SETNX命令
	 * @param key      键
	 * @param value    值，可以为空
	 * @return
	 */
	public boolean setIfObsent (String key, String value) {
		return valOpsObj.setIfAbsent(key, value);
	}
	
	/**
	 * 为key设置失效时间
	 * @param key       键
	 * @param timeout   时间大小
	 * @param unit      时间单位
	 */
	public boolean expire (String key, long timeout, TimeUnit unit) {
		return redisTemplate.expire(key, timeout, unit);
	}
	
	/**
	 * 删除key
	 * @param key 键
	 */
	public void delete (String key) {
		redisTemplate.delete(key);
	}
}

After completing the implementation of the Redis access tool class, what needs to be considered now is how to simulate competition for distributed locks. Because Redis itself supports distributed clusters, it only needs to simulate multi-threaded processing business scenarios. Thread pool is used here to simulate. The following is the specific implementation of the test class:

@RestController
@RequestMapping("test")
public class TestController {

	private static final Logger LOG = LoggerFactory.getLogger(TestController.class);  //日志对象
	@Autowired
	private RedisDao redisDao;
	//定义的分布式锁key
	private static final String LOCK_KEY = "MyTestLock";
	
	@RequestMapping(value={"testRedisLock"}, method=RequestMethod.GET)
	public void testRedisLock () {
		ExecutorService executorService = Executors.newFixedThreadPool(5);
		for (int i = 0; i < 5; i++) {
			executorService.submit(new Runnable() {
				@Override
				public void run() {
				    //获取分布式锁
					boolean flag = redisDao.setIfObsent(LOCK_KEY, "lock");
					if (flag) {
						LOG.info(Thread.currentThread().getName() + "：获取Redis分布式锁成功");
						//获取锁成功后设置失效时间
						redisDao.expire(LOCK_KEY, 2, TimeUnit.SECONDS);
						try {
							LOG.info(Thread.currentThread().getName() + "：处理业务开始");
							Thread.sleep(1000); //睡眠1000ms模拟处理业务
							LOG.info(Thread.currentThread().getName() + "：处理业务结束");
							//处理业务完成后删除锁
							redisDao.delete(LOCK_KEY);
						} catch (InterruptedException e) {
							LOG.error("处理业务异常：", e);
						}
					} else {
						LOG.info(Thread.currentThread().getName() + "：获取Redis分布式锁失败");
					}
				}
			});
		}
	}
}

Through the above code, the following questions may arise:

If the thread fails to obtain the distributed lock, Why not try to reacquire the lock?

After the thread successfully acquires the distributed lock, it sets the lock expiration time. How is the expiration time determined?

After the thread business processing is completed, why do we need to delete the lock?

We can discuss these questions.

First, the SETNX command of Redis will not perform any operation if the key already exists, so the distributed lock implemented by SETNX is not a reentrant lock. Of course, you can also retry n times through code or until the distributed lock is obtained. However, this does not guarantee fair competition, and a thread will be blocked because it has been waiting for the lock. Therefore, the distributed lock implemented by Redis is more suitable for scenarios where shared resources are written once and read multiple times.

Second, the distributed lock must set an expiration time, and the expiration time must be greater than the time required for business processing (to ensure data consistency). Therefore, during the testing phase, the time required for normal business processing should be predicted as accurately as possible, and the expiration time is set to prevent deadlock due to certain reasons in the business processing process.

Third, when the business processing is completed, the lock must be deleted.

Setting the distributed lock and setting the expiration time for the lock above are completed in two steps. A more reasonable way should be to set the distributed lock and set the expiration time for the lock in one operation. Either they both succeed or they both fail. The implementation code is as follows:

/**
* Redis访问工具类
*/
@Component
public class RedisDao {

	private static Logger logger = LoggerFactory.getLogger(RedisDao.class);
	
	@Autowired
	private StringRedisTemplate stringRedisTemplate;
	
	/**
	 * 设置分布式锁    
	 * @param key     键
	 * @param value   值
	 * @param timeout 失效时间
	 * @return
	 */
	public boolean setDistributeLock (String key, String value, long timeout) {
		RedisConnection connection = null;
		boolean flag = false;
		try {
			//获取一个连接
			connection = stringRedisTemplate.getConnectionFactory().getConnection();
			//设置分布式锁的同时为锁设置失效时间
			connection.set(key.getBytes(), value.getBytes(), Expiration.seconds(timeout), RedisStringCommands.SetOption.SET_IF_ABSENT);
			flag = true;
		} catch (Exception e) {
			logger.error("set automic lock error:", e);
		} finally {
			//使用后关闭连接
			connection.close();
		}
		return flag;
	}
	
	/**
	 * 查询key的失效时间
	 * @param key       键
	 * @param timeUnit  时间单位
	 * @return
	 */
	public long ttl (String key, TimeUnit timeUnit) {
		return stringRedisTemplate.getExpire(key, timeUnit);
	}
}

/**
* 单元测试类
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class Demo1ApplicationTests {

	private static final Logger LOG = LoggerFactory.getLogger(Demo1ApplicationTests.class);
		
	@Autowired
	private RedisDao redisDao;
	
	@Test
	public void testDistributeLock () {
		String key = "MyDistributeLock";
		//设置分布式锁，失效时间20s
		boolean result = redisDao.setDistributeLock(key, "1", 20);
		if (result) {
			LOG.info("设置分布式锁成功");
			long ttl = redisDao.ttl(key, TimeUnit.SECONDS);
			LOG.info("{}距离失效还有{}s", key, ttl);
		}
	}
}

Run the unit test class, the results are as follows:

2019-05-15 13:07:10.827 - 设置分布式锁成功
2019-05-15 13:07:10.838 - MyDistributeLock距离失效还有19s

For more Redis related knowledge, please visit the Redis usage tutorial column!

The above is the detailed content of How to use redis to implement distributed locks. For more information, please follow other related articles on the PHP Chinese website!