Redis学习（五）Redis知识点总结

##设置键“ZHKey”的过期时间为60s（单位默认为秒）
EXPIRE ZHKey 60

##移除键“ZHKey”的过期时间，使得键永不过期
PERSIST ZHKey 

#启动从服务器（6380端口），监听主服务器（6379端口），或者在redis的conf文件里面配置
redis-server --port 6380 --slaveof 127.0.0.1 6379

##1主2从1哨兵

#启动主服务器，端口为6379
redis-server --port 6379 

#启动从服务器，端口为6380，并监听IP为192.168.0.167 6379的主服务器
redis-server --port 6380 --slaveof 192.168.0.167 6379 

#启动从服务器，端口为6381，并监听IP为192.168.0.167 6379的主服务器
redis-server --port 6381 --slaveof 192.168.0.167 6379

#配置哨兵文件sentinel.conf，这里的1代表1个哨兵
PS:只用配置主服务器就好，哨兵会自动识别从服务器
sentinel monitor mymaster 192.168.0.167 6379  1

#1、开启redis的集群模式
cluster-enabled yes 

#2、配置集群模式下的配置文件
cluster-config-file nodes-6379.conf 

#3、集群内节点之间支持最长响应时间
cluster-node-timeout 15000 

#4、借助redis-tri.rb的工具可以部署集群，执行以下命令就可以成功创建集群
PS：--replicas 后面的1表示每台主服务器配置1个从服务器
redis-trib.rb create --replicas 1 127.0.0.1:6379 127.0.0.1:6380 127.0.0.1:6381 127.0.0.1:6382 127.0.0.1:6383 127.0.0.1:6384 

##当且仅当键“ZHKey”不存在时，set一个键为“ZHKey”的字符串键值对，返回1；若键“ZHKey”存在，则什么都不做，返回0
SETNX ZHKey 值

##为键设置一个超时时间，单位为秒，超过这个时间锁会自动释放，避免死锁。
EXPIRE ZHKey 60 #设置键为“ZHKey”的键值对，超时时间为60秒

##删除键为“ZHKey”的键值对
DELETE ZHKey

/**
 * Redis实现分布式锁
 */
public class RedisLock {
    //JedisPool（Jedis线程池）
    private final JedisPool jedisPool;

    /**
     * 构造方法实例化JedisPool
     *
     * @param jedisPool
     */
    public RedisLock(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 加锁
     *
     * @param lockName       锁的key
     * @param acquireTimeout 获取超时时间
     * @param timeout        锁的超时时间
     * @return 锁标识(即锁的值 ， 用于释放锁时的校验)
     */
    public String lockWithTimeout(String lockName, long acquireTimeout, long timeout) {
        //Jedis实例
        Jedis conn = null;
        //锁的值（用于释放锁时的校验）
        String redisValue = null;
        try {
            // 获取连接
            conn = jedisPool.getResource();
            // 随机生成一个randomValue
            String randomValue = UUID.randomUUID().toString();
            // 锁名，即key值
            String lockKey = "lock:" + lockName;
            // 超时时间，上锁后超过此时间则自动释放锁
            int lockExpire = (int) (timeout / 1000);
            // 获取锁的超时时间，超过这个时间则放弃获取锁
            long end = System.currentTimeMillis() + acquireTimeout;
            // 当处于锁的超时时间之内时，进行判断(在超时时间内或者方法体返回值之前，会一直处于while块中)
            while (System.currentTimeMillis() < end) {
                if (conn.setnx(lockKey, randomValue) == 1) {
                    //不存在当前键时，设置一个新的键值对，并设置超时时间
                    conn.expire(lockKey, lockExpire);
                    // 返回randomValue值，用于释放锁时间确认
                    redisValue = randomValue;
                    return redisValue;
                }
                // 返回-1代表key没有设置超时时间，为key设置一个超时时间
                if (conn.ttl(lockKey) == -1) {
                    conn.expire(lockKey, lockExpire);
                }

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        } catch (JedisException e) {
            e.printStackTrace();
        } finally {
            //关闭Jedis
            if (conn != null) {
                conn.close();
            }
        }
        return redisValue;
    }

    /**
     * 释放锁
     *
     * @param lockName    锁的key
     * @param randomValue 释放锁的标识（即锁的值）
     * @return
     */
    public boolean releaseLock(String lockName, String randomValue) {
        //Jedis实例
        Jedis conn = null;
        // 锁名，即key值
        String lockKey = "lock:" + lockName;
        //锁是否释放成功标识
        boolean releaseFlag = false;
        try {
            // 获取连接
            conn = jedisPool.getResource();
            while (true) {
                // 监视lock，准备开始事务
                conn.watch(lockKey);
                // 通过前面返回的randomValue值判断是不是该锁，若是该锁，则删除，释放锁
                if (randomValue.equals(conn.get(lockKey))) {
                    //conn.multi()标记开始事务
                    Transaction transaction = conn.multi();
                    //删除键值对
                    transaction.del(lockKey);
                    //transaction.exec()执行事务块内命令，并返回结果集
                    List<Object> results = transaction.exec();
                    if (results == null) {
                        continue;
                    }
                    releaseFlag = true;
                }
                //解除watch对所有key的监控
                conn.unwatch();
                break;
            }
        } catch (JedisException e) {
            e.printStackTrace();
        } finally {
            //关闭Jedis
            if (conn != null) {
                conn.close();
            }
        }
        return releaseFlag;
    }
}

/**
 * 模拟使用redis实现分布式锁的业务代码
 */
public class redisLockService {

    //JedisPool池对象
    private static JedisPool pool = null;

    //Redis分布式锁对象
    private RedisLock lock = new RedisLock(pool);

    //静态代码块初始化JedisPool（最好放在配置文件中读取）
    static {
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大连接数（表示同时最多有100个数据库连接）
        config.setMaxTotal(100);
        // 设置最大空闲数（表示连接池中最多可空闲maxIdle个连接 ，这里取值为20，表示即使没有数据库连接时依然可以保持20空闲的连接，而不被清除，随时处于待命状态。）
        config.setMaxIdle(8);
        // 设置最大连接等待时间
        config.setMaxWaitMillis(1000 * 100);
        // 在borrow一个jedis实例时，是否需要验证，若为true，则所有jedis实例均是可用的
        config.setTestOnBorrow(true);
        pool = new JedisPool(config, "127.0.0.1", 6379, 3000);
    }

    public void lockSomeThings() {
        //加锁，返回锁的value值，供解锁时使用
        String redisValue = lock.lockWithTimeout("goodsStockReduce", 5000, 1000);
        //TODO 这里可添加需要使用分布式锁的代码（如库存扣减服务）
        System.out.println(Thread.currentThread().getName() + "获得了锁");
        //解锁
        lock.releaseLock("resource", redisValue);
    }
}