Redis常见用途

叁歲伎倆 2022-05-23 08:16 256阅读 0赞

一、全局ID

/** ID最大值 */
        final static long maxNum = 2100000000;
        /** 初始ID */
        final static long startNum = 1000000000;
        /** redis步长 */
        final static long redisStepLength = 1;
    
        /** * 获取redis主键序列号(10位长度) * * @return * @throws RedisException */
        private long getAtomicLong(String key) throws RedisException {
    
            try {
                // 获取redis该key的值
                RAtomicLong seqLong = redissonClient.getAtomicLong(key);
                if (seqLong.get() > maxNum || seqLong.get() < startNum) {
                    seqLong.set(startNum);
                    seqLong.expire(1, TimeUnit.DAYS);
                }
                seqLong.addAndGet(redisStepLength);
                return seqLong.get();
            } catch (Exception e) {
                log.error("获取redis主键序列号异常: ", e);
                return RandomUtils.nextLong(startNum, maxNum);
            }
        }
    
        /** * 生成表主键ID流水号 * * @param key * redisKEY，结构为param1:param2:param3.... * @return 6+10=16位长度 * @throws RedisException */
        public Long getSeq_16(String key) throws RedisException {
    
            checkForKey(key);
            String DateKEY = DateFormatUtils.format(new Date(), "yyMMdd");
            return Long.valueOf(DateKEY + getAtomicLong(key + ":" + DateKEY));
        }

二、分布锁

/** * when the time that thread execute business > leaseTime,it is not safe (maybe * others have already get the lock); * * But we should not hold the lock all the time，setting leaseTime is necessary * * * @param key * lockKey * @param waitTime * 最大等候锁时间 * @param leaseTime * 过期自动释放锁时间 * @param timeUnit * 时间单位 * @throws RedisException * throw when locked failed */
        public <T> T execute(String key, long waitTime, long leaseTime, TimeUnit timeUnit, LockCallback<T> callback)
                throws RedisException {
    
            checkForKey(key);
    
            RLock rLock = redissonClient.getLock(key);
            if (StringUtils.isBlank(key) || waitTime <= 0 || leaseTime <= 0 || timeUnit == null) {
                throw new RedisException(RedisErrorCode.KEY_LOCKED_FAILED);
            }
            boolean isLocked = false;
            try {
                // 尝试获取锁
                isLocked = rLock.tryLock(waitTime, leaseTime, timeUnit);
    
                if (!isLocked) {
                    log.debug("locked failed ,key [{}]", key);
                    throw new RedisException(RedisErrorCode.KEY_LOCKED_FAILED);
                }
    
                return callback.doWithLock();
    
            } catch (InterruptedException e) {
                log.debug("locked failed ,key [{}]: ", key, e);
                throw new RedisException(RedisErrorCode.KEY_LOCKED_FAILED);
            } finally {
                if (isLocked) {
                    log.debug("Unlock {} ", key);
                    rLock.unlock();
                    log.debug("Unlock {} SUCCESS", key);
                }
            }
        }

调用分布锁锁的例子

public static void main(String[] args) {
    
            RedisUtils redisUtils = new RedisUtils();
            String response;
            try {
                redisUtils.execute("lock:key:seq", 3000, 4000, TimeUnit.MILLISECONDS, new LockCallback<String>() {
    
                    public String doWithLock() {
    
                        /* * do business in Lock */
    
                        return null;
                    }
    
                });
            } catch (RedisException e) {
    
                /* * lock failed */
            }
    
        }