Redis实现漫衍式锁的正确姿势

Redis漫衍式锁实现的正确姿势的实当代码：

public interface DistributedLock { 
    /** 
     * 获取锁 
     * @author zhi.li 
     * @return 锁标识 
     */ 
    String acquire(); 
 
    /** 
     * 开释锁 
     * @author zhi.li 
     * @param indentifier 
     * @return 
     */ 
    boolean release(String indentifier); 
} 
 
/** 
 * @author zhi.li 
 * @Description 
 * @created 2019/1/1 20:32 
 */ 
@Slf4j 
public class RedisDistributedLock implements DistributedLock{ 
 
    private static final String LOCK_SUCCESS = "OK"; 
    private static final Long RELEASE_SUCCESS = 1L; 
    private static final String SET_IF_NOT_EXIST = "NX"; 
    private static final String SET_WITH_EXPIRE_TIME = "PX"; 
 
    /** 
     * redis 客户端 
     */ 
    private Jedis jedis; 
 
    /** 
     * 漫衍式锁的键值 
     */ 
    private String lockKey; 
 
    /** 
     * 锁的超时时刻 10s 
     */ 
    int expireTime = 10 * 1000; 
 
    /** 
     * 锁守候，防备线程饥饿 
     */ 
    int acquireTimeout  = 1 * 1000; 
 
    /** 
     * 获取指定键值的锁 
     * @param jedis jedis Redis客户端 
     * @param lockKey 锁的键值 
     */ 
    public RedisDistributedLock(Jedis jedis, String lockKey) { 
        this.jedis = jedis; 
        this.lockKey = lockKey; 
    } 
 
    /** 
     * 获取指定键值的锁,同时配置获取锁超时时刻 
     * @param jedis jedis Redis客户端 
     * @param lockKey 锁的键值 
     * @param acquireTimeout 获取锁超时时刻 
     */ 
    public RedisDistributedLock(Jedis jedis,String lockKey, int acquireTimeout) { 
        this.jedis = jedis; 
        this.lockKey = lockKey; 
        this.acquireTimeout = acquireTimeout; 
    } 
 
    /** 
     * 获取指定键值的锁,同时配置获取锁超时时刻和锁逾期时刻 
     * @param jedis jedis Redis客户端 
     * @param lockKey 锁的键值 
     * @param acquireTimeout 获取锁超时时刻 
     * @param expireTime 锁失效时刻 
     */ 
    public RedisDistributedLock(Jedis jedis, String lockKey, int acquireTimeout, int expireTime) { 
        this.jedis = jedis; 
        this.lockKey = lockKey; 
        this.acquireTimeout = acquireTimeout; 
        this.expireTime = expireTime; 
    } 
 
    @Override 
    public String acquire() { 
        try { 
            // 获取锁的超时时刻，高出这个时刻则放弃获取锁 
            long end = System.currentTimeMillis() + acquireTimeout; 
            // 随机天生一个value 
            String requireToken = UUID.randomUUID().toString(); 
            while (System.currentTimeMillis() < end) { 
                String result = jedis.set(lockKey, requireToken, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime); 
                if (LOCK_SUCCESS.equals(result)) { 
                    return requireToken; 
                } 
                try { 
                    Thread.sleep(100); 
                } catch (InterruptedException e) { 
                    Thread.currentThread().interrupt(); 
                } 
            } 
        } catch (Exception e) { 
            log.error("acquire lock due to error", e); 
        } 
 
        return null; 
    } 
 
    @Override 
    public boolean release(String identify) { 
　 if(identify == null){ 
            return false; 
        } 
 
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"; 
        Object result = new Object(); 
        try { 
            result = jedis.eval(script, Collections.singletonList(lockKey), 
                Collections.singletonList(identify)); 
        if (RELEASE_SUCCESS.equals(result)) { 
            log.info("release lock success, requestToken:{}", identify); 
            return true; 
        }}catch (Exception e){ 
            log.error("release lock due to error",e); 
        }finally { 
            if(jedis != null){ 
                jedis.close(); 
            } 
        } 
 
        log.info("release lock failed, requestToken:{}, result:{}", identify, result); 
        return false; 
    } 
} 

下面就以秒杀库存数目为场景，测试下上面实现的漫衍式锁的结果。详细测试代码如下：
public class RedisDistributedLockTest { 
    static int n = 500; 
    public static void secskill() { 
        System.out.println(--n); 
    } 
 
    public static void main(String[] args) { 
        Runnable runnable = () -> { 
            RedisDistributedLock lock = null; 
            String unLockIdentify = null; 
            try { 
                Jedis conn = new Jedis("127.0.0.1",6379); 
                lock = new RedisDistributedLock(conn, "test1"); 
                unLockIdentify = lock.acquire(); 
                System.out.println(Thread.currentThread().getName() + "正在运行"); 
                在此我向各人保举一个架构进修交换圈：830478757 辅佐打破瓶颈 晋升思想手段 
                secskill(); 
            } finally { 
                if (lock != null) { 
                    lock.release(unLockIdentify); 
                } 
            } 
        }; 
 
        for (int i = 0; i < 10; i++) { 
            Thread t = new Thread(runnable); 
            t.start(); 
        } 
    } 
} 

运行结果如下图所示。从图中可以看出，统一个资源在统一个时候只能被一个线程获取，从而担保了库存数目N的递减是次序的。

五、总结

（编辑：湖南网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!