redis分布式锁实现控制并发

最近项目有一个关于征信协议生成pdf，要求客户签订的第一份协议生成pdf，由于是服务器集群，所以要用到分布式锁的概念。

写完后，写了个例子总结了下,直接上例子

import java.util.HashSet;

import java.util.Set;

import java.util.concurrent.TimeUnit;

import org.apache.commons.lang.math.RandomUtils;

import org.springframework.data.redis.core.TimeoutUtils;

import redis.clients.jedis.HostAndPort;

import redis.clients.jedis.JedisCluster;

public class Test {

    

    static Set<HostAndPort> haps_dest_dev = new HashSet<HostAndPort>();

    static JedisCluster jedisCluster;

    static {

        haps_dest_dev.add(new HostAndPort("172.29.0.97", 6379));

        haps_dest_dev.add(new HostAndPort("172.29.0.97", 6389));

        haps_dest_dev.add(new HostAndPort("172.29.0.97", 6399));

        haps_dest_dev.add(new HostAndPort("172.29.0.98", 6379));

        haps_dest_dev.add(new HostAndPort("172.29.0.98", 6389));

        haps_dest_dev.add(new HostAndPort("172.29.0.98", 6399));

        jedisCluster = new JedisCluster(haps_dest_dev);

    }

    

    /** 毫秒与毫微秒的换算单位 1毫秒 = 1000000毫微秒 */

    public static final long MILLI_NANO_CONVERSION = 1000 * 1000L;

    /** 默认超时时间（毫秒） */

    public static final long DEFAULT_TIME_OUT = 1000;

    

//    private volatile boolean locked = false;

    

    /** 

     * 获取锁 

     * @param timeout     获取锁的等待时间  毫秒

     * @param expireSecs  锁的有效时间，必须大于0 毫秒

     * @return 

     */  

    private boolean lock(String lockKey, long timeout, int expireSecs) throws InterruptedException {  

        if (expireSecs <= 0) {  

            throw new IllegalArgumentException("Param expireSecs must lager than zero.");  

        }  

        long nano = System.nanoTime();  

        timeout *= MILLI_NANO_CONVERSION;  

        try {  

            while ((System.nanoTime() - nano) < timeout) {  

            long expires = System.currentTimeMillis() + expireSecs + 1;

            // 5秒之后锁到期

                String expiresStr = String.valueOf(expires); //锁到期时间

                // 获取到锁

                if (jedisCluster.setnx(lockKey, String.valueOf(expiresStr)) == 1) {

                // lock acquired

//                 locked = true;

                jedisCluster.expire(lockKey, (int) TimeoutUtils.toSeconds(expireSecs, TimeUnit.MILLISECONDS)); 

                    return true;  

                }  

                // 没有获取到锁

                String currentValueStr = jedisCluster.get(lockKey); 

                // expireMsecs（5秒）锁的有效期内无法进入if判断，如果锁超时了

                if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {

                //判断是否为空，不为空的情况下，如果被其他线程设置了值，则第二个条件判断是过不去的

                    // lock is expired

                // 如果锁超时重新设置

                    String oldValueStr = jedisCluster.getSet(lockKey, expiresStr);

                    //获取上一个锁到期时间，并设置现在的锁到期时间，

                    //只有一个线程才能获取上一个线上的设置时间，因为jedis.getSet是同步的

                    // 值相同说明是同一个线程的操作，获取锁成功

                    if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {

                    //防止误删（覆盖，因为key是相同的）了他人的锁——这里达不到效果，这里值会被覆盖，但是因为什么相差了很少的时间，所以可以接受

                    //如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁

                        // lock acquired
//                     locked = true;

                    jedisCluster.expire(lockKey, (int) TimeoutUtils.toSeconds(expireSecs, TimeUnit.MILLISECONDS));

                        return true;

                    } else {

                        // 被其他线程抢先获取锁

//                        locked = false;

                    }

                }

               // 锁没有超时，继续等待

            }  

            

            Thread.sleep(3, RandomUtils.nextInt(500));  

        } catch (Exception e) {  

            throw new RuntimeException("Locking error", e);  

        } 

        return false;  

    }

    

    

    /**

     * 释放锁

     */

    public void releaseLock(String lockKey){

        try {

            long current = System.currentTimeMillis();  

            // 避免删除非自己获取得到的锁

            if (current < Long.valueOf(jedisCluster.get(lockKey)))

            jedisCluster.del(lockKey);

//                locked = false;

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public static void main(String[] args) {

    Test t = new Test();

        try {

        if (t.lock("lock:aa", DEFAULT_TIME_OUT, 5000)) {

        System.out.println("获取锁");

        } else {

        System.out.println("未获取锁");

        }

        } catch (Exception e1) {

            e1.printStackTrace();

        }

    }

}