分布式锁的原理及实现

最新推荐文章于 2024-07-16 22:54:10 发布

凝神遐想

最新推荐文章于 2024-07-16 22:54:10 发布

阅读量442

点赞数 10

文章标签：缓存分布式

本文链接：https://blog.csdn.net/kaiwen_100/article/details/136508020

版权

在传统的单机环境中，通常可以使用 互斥锁 或者 读写锁 来控制并发访问。但在分布式系统中，由于存在多个节点和网络通信延迟等问题，使用互斥锁或读写锁就不再适用。

这时就需要分布式锁来控制并发访问

分布式锁是基于某种共享存储机制实现，比如分布式缓存，数据库或者文件系统等。具体的实现方式分为乐观锁和悲观锁两种

乐观锁：在每次访问共享资源时，都假设其他节点不会同时修改该资源，并在访问前检查是否有其他节点对该资源进行了修改。如果检查发现有其他节点对该资源进行了修改，那么当前节点会进行回滚并重试，直到成功为止。乐观锁的优点是不需要加锁，因此可以提高系统的并发性能，缺点是可能会导致频繁的重试操作，增加系统负担。
悲观锁：在每次访问共享资源时，都假设其他节点会同时修改该资源，并对该资源进行加锁。加锁可以采用分布式锁算法，比如基于共享缓存的实现方式，比如Redis等。加锁后，其他节点就无法对该资源进行修改，直到当前节点完成操作并释放锁。悲观锁的优点是保证数据一致性，缺点是加锁操作可能会影响系统的性能。

基于Redis实现分布式锁
Redis是一种高性能的键值存储系统，支持多种数据结构，包括字符串、哈希表、列表、集合、有序集合等。Redis支持多种分布式锁算法，比如SETNX、BLPOP、BRPOP等。

其中，SETNX命令是Redis中最常用的分布式锁算法之一。该算法的实现思路是在Redis中创建一个键值对，其中键表示锁的名称，值表示锁的拥有者。如果该键不存在，则创建该键，并将其值设置为当前节点的ID。如果该键已经存在，则说明锁已经被其他节点占用，当前节点需要等待一段时间后再尝试获取锁。当前节点完成对共享资源的访问后，需要将该键值对删除，以释放锁。

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

            if (LOCK_SUCCESS.equals(result)) {
                return true;
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return false;
    }
    
/**
     * 释放分布式锁
     * @param lockKey 锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public boolean releaseDistributedLock(String lockKey, String requestId) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();

            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));

            if (RELEASE_SUCCESS.equals(result)) {
                return true;
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return false;

public void updateTaskApproval() {
	boolean flag = jedisUtils.tryGetDistributedLock("LK_APPROVAL_SRV_" + token + taskId, token + taskId, 30000);
	try{
		if (flag) {
		log.info("加锁成功:{},{}", "LK_APPROVAL_SRV_" + token + taskId, token + taskId);
                String key = token + "_" + taskId;
                if (null != redisHandler.get(key)) {
                    return packProducterListSuccessResponse(400, "请勿重复提交", "message", "请勿重复提交");
                }
                redisHandler.set(key, key, 3L, TimeUnit.SECONDS);
         }
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
            if (flag) {
                boolean releaseFlag = jedisUtils.releaseDistributedLock("LK_APPROVAL_SRV_" + token + taskId, token + taskId);
                log.info("释放锁[{}]{}", "LK_APPROVAL_SRV_" + token + taskId, releaseFlag ? "成功" : "失败,30s后自动释放锁");
            } else {
                log.info("锁{}已释放", "LK_APPROVAL_SRV_" + token + taskId);
            }
        }
}