spring + redisson 集群同步锁

一.引入pom文件

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>2.2.13</version>
</dependency>

import org.redisson.Config;
import org.redisson.Redisson;
import org.redisson.RedissonClient;
import org.redisson.core.RAtomicLong;
import org.redisson.core.RLock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.TimeUnit;

/**
 * @author Ailen
 * @version Id: DistributedRedisLock.java,Exp $$
 */
public class DistributedRedisLock {

    // NX是不存在时才set， XX是存在时才set， EX是秒，PX是毫秒

    private static final Logger logger = LoggerFactory.getLogger(DistributedRedisLock.class);

    private static RedissonClient redisson = RedissonManager.getRedisson();

    public static RLock getLock(String lockKey, int expireTime, TimeUnit timeUnit) {
        RLock mylock = redisson.getLock(lockKey);
        mylock.lock(expireTime, timeUnit);
        logger.info("获取分布式锁 Key:{}", lockKey);
        return mylock;
    }

    public static void unLock(String lockKey) {
        RLock mylock = redisson.getLock(lockKey);
        mylock.unlock();
        logger.info("释放分布式锁 Key:{}", lockKey);
    }


    static class RedissonManager {
        private static final String RAtomicName = "genId_";
        private static Config config = new Config();
        private static RedissonClient redisson = null;

        public static void init() {
            try {
                config.useClusterServers()
                        //设置集群状态扫描间隔
                        .setScanInterval(200000)
                        //设置对于master节点的连接池中连接数最大为10000
                        .setMasterConnectionPoolSize(10000)
                        //设置对于slave节点的连接池中连接数最大为500
                        .setSlaveConnectionPoolSize(10000)
                        //如果当前连接池里的连接数量超过了最小空闲连接数，而同时有连接空闲时间超过了该数值，那么这些连接将会自动被关闭，并从连接池里去掉。时间单位是毫秒。
                        .setIdleConnectionTimeout(10000)
                        //同任何节点建立连接时的等待超时。时间单位是毫秒。
                        .setConnectTimeout(30000)
                        //等待节点回复命令的时间。该时间从命令发送成功时开始计时。
                        .setTimeout(3000)
                        //当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。
                        .setRetryInterval(3000)
                        .addNodeAddress("redis://10.10.156.241:7000", "redis://10.10.156.241:7001", "redis://10.10.156.241:7002");
                redisson = Redisson.create(config);
                RAtomicLong atomicLong = redisson.getAtomicLong(RAtomicName);
                //自增设置为从1开始
                atomicLong.set(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public static RedissonClient getRedisson() {
            if (redisson == null) {
                RedissonManager.init(); //初始化
            }
            return redisson;
        }

        /**
         * 获取redis中的原子ID
         */
        public static Long nextID() {
            RAtomicLong atomicLong = getRedisson().getAtomicLong(RAtomicName);
            atomicLong.incrementAndGet();
            return atomicLong.get();
        }
    }

}