基于Redisson简单实现分布式锁

redission配置

@Data
@Configuration
@ConfigurationProperties(prefix = "redisson")
public class RedissonConfig {

    private String address;

    @Bean
    public RedissonClient getRedisson() throws Exception {
        Config config = new Config();
        config.useSingleServer()
                .setAddress(address);
        RedissonClient redisson = Redisson.create(config);

        System.out.println(redisson.getConfig().toJSON());
        return redisson;
    }
}

不同redis模式的配置

单机:

config.useSingleServer().setAddress(address);

集群/哨兵/主从

集群模式
config.useClusterServers().setScanInterval(2000) 
    .addNodeAddress("redis://127.0.0.1:7000", "redis://127.0.0.1:7001")
    .addNodeAddress("redis://127.0.0.1:7002");
哨兵模式
config.useSentinelServers()
    .setMasterName("mymaster")
    // use "rediss://" for SSL connection
    .addSentinelAddress("redis://127.0.0.1:26389", "redis://127.0.0.1:26379")
    .addSentinelAddress("redis://127.0.0.1:26319");
主从模式
config.useMasterSlaveServers()
    // use "rediss://" for SSL connection
    .setMasterAddress("redis://127.0.0.1:6379")
    .addSlaveAddress("redis://127.0.0.1:6389", "redis://127.0.0.1:6332", "redis://127.0.0.1:6419")
    .addSlaveAddress("redis://127.0.0.1:6399");

RedissonUtil

    @Autowired
    private RedissonClient redissonClient;
    /**
     * 锁住不设置超时时间(拿不到lock就不罢休，不然线程就一直block)

     * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    /**
     * leaseTime为加锁时间，单位为秒
    

     * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
        return null;
    }

    /**
     * timeout为加锁时间，时间单位由unit确定


     * @param timeout
     * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey, TimeUnit unit, long timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }

    /**
     * 尝试获取锁

     * @return boolean
     */
    public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 通过lockKey解锁
 
     * @return void
     */
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    /**
     * 直接通过锁解锁

     * @return void
     */
    public void unlock(RLock lock) {
        lock.unlock();
    }

}

业务层

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean test() {
        try {
            logger.info("============={} 线程访问开始============", Thread.currentThread().getName());
            boolean lock = redissonUtil.tryLock("vvv", TimeUnit.SECONDS, 3L, 5L);
            logger.info("锁的状态" + lock + "============={} 线程访问开始============", Thread.currentThread().getName());
            if (lock) {
                logger.info("线程:{}，获取到了锁", Thread.currentThread().getName() + "+++++++++++++++++++++++++++++");

                //TODO 添加上自己要锁的代码  锁的行数越少越好

                Thread.sleep(100);
            } else {
                logger.info("todo ++++++");
            }
        } catch (Exception e) {
            logger.info("错误信息：{}", e.toString());
            logger.info("线程：{} 获取锁失败", Thread.currentThread().getName());
            throw new VException("退出");
        }finally {
            logger.info("======释放锁======" + Thread.currentThread().getName() + "——————————————————————————————————————————————————————————————————————————");
            redissonUtil.unlock("vvv");
            return true;
        }
    }