SpringBoot Redis实现分布式锁

SpringBoot Redis实现分布式锁

工作上遇到一个问题，在几乎同时插入了两条相同的数据，正常的逻辑是如果数据库中没有就插入，有就做修改数据的操作。分析日志发现，在同一时间，有两个相同的HTTP请求到服务器，而我们的代码先执行select 语句，然后执行insert语句，可能这两个请求同时select，发现数据库中没有，所有都执行了insert语句。
针对这个问题，我能想到可以有如下几种解决方法

加锁

在方法前加锁(synchronized关键字)，或者在方法里面加锁。但考虑到在集群情况下，依然可能存在问题，故没有采用该方案

给数据库中的表加唯一约束

可以给数据库的表中的字段加上唯一约束，这样到执行insert语句时，当发现数据库中已经存在该记录，就会抛出异常！但由于公司DBA规定不能给字段加唯一约束，所以没有采取该方案!

加分布式锁

由于项目使用了Redis，所以直接用Redis实现分布式锁
注意，以下代码的实现由问题,具体请点击查看原因和更好的方式
代码如下：

package com.cdvcredit.redis.manger.core;

import java.util.List;
import java.util.UUID;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisLockService {

    private Logger logger = LoggerFactory.getLogger(getClass().getSimpleName());

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public String lock(String lockName){
        return lockWithTimeout(lockName, 3000L, 3000L);
    }

    /**
     * 获取锁
     * @param locaName
     * @param acquireTimeout
     * @param timeout
     * @return
     */
    public String lockWithTimeout(String locaName, long acquireTimeout, long timeout){
        String retIdentifier = null;
        RedisConnectionFactory connectionFactory = stringRedisTemplate.getConnectionFactory();
        RedisConnection redisConnection = connectionFactory.getConnection();
        // 获取连接
        // 随机生成一个value
        String identifier = UUID.randomUUID().toString();
        // 锁名，即key值
        String lockKey = "lock:" + locaName;
        // 超时时间，上锁后超过此时间则自动释放锁
        int lockExpire = (int)(timeout / 1000);
        // 获取锁的超时时间，超过这个时间则放弃获取锁
        long end = System.currentTimeMillis() + acquireTimeout;
        while (System.currentTimeMillis() < end) {
            if (redisConnection.setNX(lockKey.getBytes(), identifier.getBytes())) {
                redisConnection.expire(lockKey.getBytes(), lockExpire);
                // 返回value值，用于释放锁时间确认
                retIdentifier = identifier;
                RedisConnectionUtils.releaseConnection(redisConnection, connectionFactory);
                return retIdentifier;
            }
            // 返回-1代表key没有设置超时时间，为key设置一个超时时间
            if (redisConnection.ttl(lockKey.getBytes()) == -1) {
                redisConnection.expire(lockKey.getBytes(), lockExpire);
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                logger.warn("获取到分布式锁：线程中断！");
                Thread.currentThread().interrupt();
            }
        }
        RedisConnectionUtils.releaseConnection(redisConnection, connectionFactory);
        return retIdentifier;
    }

     /**
     * 释放锁
     * @param lockName 锁的key
     * @param identifier 释放锁的标识
     * @return
     */
    public boolean releaseLock(String lockName, String identifier) {
        if(identifier == null || "".equals(identifier)){
            return false;
        }
        RedisConnectionFactory connectionFactory = stringRedisTemplate.getConnectionFactory();
        RedisConnection redisConnection = connectionFactory.getConnection();
        String lockKey = "lock:" + lockName;
        boolean releaseFlag = false;
        while (true) {
            try{
                // 监视lock，准备开始事务
                redisConnection.watch(lockKey.getBytes());
                // 通过前面返回的value值判断是不是该锁，若是该锁，则删除，释放锁
                byte[] valueBytes = redisConnection.get(lockKey.getBytes());
                if(valueBytes == null){
                    redisConnection.unwatch();
                    releaseFlag = false;
                    break;
                }
                String identifierValue = new String(valueBytes);
                if (identifier.equals(identifierValue)) {
                    redisConnection.multi();
                    redisConnection.del(lockKey.getBytes());
                    List<Object> results = redisConnection.exec();
                    if (results == null) {
                        continue;
                    }
                    releaseFlag = true;
                }
                redisConnection.unwatch();
                break;
            }catch(Exception e){
                logger.warn("释放锁异常", e);
                e.printStackTrace();
            }
        }
        RedisConnectionUtils.releaseConnection(redisConnection, connectionFactory);
        return releaseFlag;
    }

}

最开始没有调用RedisConnectionUtils.releaseConnection(redisConnection, connectionFactory);释放连接，导致每隔一段时间，系统就运行不了，HTTP请求超时。记录一下，防止下次犯同样的错误!