Redis分布式锁

先讲下流程：

1.在redis中设置一个锁setnx(lockkey , currenttime+timeout)。

2.返回1代表之前没有这个锁，那么就调用expire(lockkey)来重新设置超时时间，执行业务，接下来del(key)，释放锁，最后结束。

3.返回0代表有这个锁，那么传统流程中就直接结束。优化后，调用get(lockkey)来获取这个锁的超时时间的value。

3.1接下来判断如果value不是空，并且已经超时的话，那么调用getset(lockkey,currenttime+timeout)方法，重新设置value值，同时会返回一个老的值，判断如果这个值为空，或者旧值和新值相等，那么代表这个锁没有变化，获取锁成功，调用第二步操作。

3.2如果条件不满足，那么结束任务。

Redis+Scheduled

模拟一个需求，用户提交订单后，若干时间后如果还没有支付，那么关闭这个订单。那么我们需要用定时任务做轮询，把超时的订单全部删除。

在分布式的情况下，多个程序，我只需要其中一个运行这个定时任务，不需要所有程序都做轮询，因此我们可以用到redis锁来管理。接下来写代码：

@Component
public class CloseOrderTask {

    @Scheduled(cron = "0 */1 * * * ?")
    public void closeOrder() throws InterruptedException {
        System.out.println("关闭订单定时任务启动");
        long timeout = Long.parseLong(PropertiesUtils.getProperty("lock.timeout", "5000"));
        Long setnxResult = RedisShardedPoolUtil.setnx("CLOSE_ORDER_TASK_LOCK" , String.valueOf(System.currentTimeMillis() + timeout));
        if (setnxResult != null && setnxResult.intValue() == 1){
            //设置成功，获取锁
            closeOrder("CLOSE_ORDER_TASK_LOCK");
        }else {
            System.out.println("没有获得锁");
        }
        System.out.println("关闭订单定时任务关闭");
    }

    private void closeOrder(String lockName) throws InterruptedException {
        //设置key的有效期50秒，防止死锁
        RedisShardedPoolUtil.expire(lockName , 50);
        System.out.println(Thread.currentThread().getName() + "获取到锁" + lockName);
        System.out.println("执行关闭订单操作");
        Thread.sleep(3000);
        RedisShardedPoolUtil.del(lockName);
        System.out.println(Thread.currentThread().getName() + "释放锁" + lockName);
    }
}

public static Long setnx(String key , String value){
        ShardedJedis jedis = null;
        Long result = null;
        try {
            jedis = RedisShardedPool.getJedis();
            result = jedis.setnx(key , value);
        } catch (Exception e) {
            e.printStackTrace();
            RedisShardedPool.returnBrokenResource(jedis);
            return result;
        }
        RedisShardedPool.returnResource(jedis);
        return result;
    }

每次请求都会去redis中找是否有锁，如果有的话就不做删除，如果没有的话就插入一条，并且设置超时时间。运行结果：

tomcat1：

tomcat2：

这样就实现了只有一个可以运行的目的，但是这里会有一个死锁的问题：假如程序运行到第9行，刚set进值，还没有设置超时时间的时候，程序崩掉了，那么这个锁就一直待在redis中了，那也就死锁了。 

这种情况我们可以在定时任务中加一个方法：

    @PreDestroy
    public void delLock(){
        RedisShardedPoolUtil.del("CLOSE_ORDER_TASK_LOCK");
    }

@PreDestroy在程序结束时运行，但是仅限于shutdown这种平和的方式，如果kill进程，这个也是没有用的，因此我们需要演进一下代码：

@Scheduled(cron = "0 */1 * * * ?")
    public void closeOrder2() throws InterruptedException {
        System.out.println("关闭订单定时任务启动");
        long timeout = Long.parseLong(PropertiesUtils.getProperty("lock.timeout", "5000"));
        Long setnxResult = RedisShardedPoolUtil.setnx("CLOSE_ORDER_TASK_LOCK" , String.valueOf(System.currentTimeMillis() + timeout));
        if (setnxResult != null && setnxResult.intValue() == 1){
            //设置成功，获取锁
            closeOrder("CLOSE_ORDER_TASK_LOCK");
        }else {
            //未获取到锁，继续判断时间戳，看是否可以重置并获取到锁
            String lockValueStr = RedisShardedPoolUtil.get("CLOSE_ORDER_TASK_LOCK");
            if (lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)){
                String getSetResult = RedisShardedPoolUtil.getSet("CLOSE_ORDER_TASK_LOCK" , String.valueOf(System.currentTimeMillis() + timeout));
                //再次用当前时间戳getset
                //返回给定的key的旧值，通过判断旧值来决定是否可以获取锁
                if (lockValueStr == null || (lockValueStr != null && StringUtils.equals(lockValueStr , getSetResult))){
                    closeOrder("CLOSE_ORDER_TASK_LOCK");
                }else {
                    System.out.println(Thread.currentThread().getName() + "没有获得锁");
                }
            }else {
                System.out.println(Thread.currentThread().getName() + "没有获得锁");
            }
        }
        System.out.println("关闭订单定时任务关闭");
    }

    public static String getSet(String key , String value){
        ShardedJedis jedis = null;
        String result = null;
        try {
            jedis = RedisShardedPool.getJedis();
            result = jedis.getSet(key , value);
        } catch (Exception e) {
            e.printStackTrace();
            RedisShardedPool.returnBrokenResource(jedis);
            return result;
        }
        RedisShardedPool.returnResource(jedis);
        return result;
    }

其实通过代码就很清楚地看出流程了，里面用了多重防死锁，这是因为在分布式环境下，程序可能不止2台，那么所有的机器同时运行大概率会有类似问题，所以我们通过多重验证来判断是否获得锁。