分布式锁的三种实现方式

1、zookeeper

一、实现原理：

基于zookeeper瞬时有序节点实现的分布式锁，其主要逻辑以下（该图来自于IBM网站）。大体思想即为：每一个客户端对某个功能加锁时，在zookeeper上的与该功能对应的指定节点的目录下，生成一个惟一的瞬时有序节点。判断是否获取锁的方式很简单，只须要判断有序节点中序号最小的一个。当释放锁的时候，只需将这个瞬时节点删除便可。同时，其能够避免服务宕机致使的锁没法释放，而产生的死锁问题。

二、优势

锁安全性高，zk可持久化

三、缺点

性能开销比较高。由于其须要动态产生、销毁瞬时节点来实现锁功能。

四、实现

能够直接采用zookeeper第三方库curator便可方便地实现分布式锁。如下为基于curator实现的zk分布式锁核心代码：

 

@Override
public boolean tryLock(LockInfo info) {
    InterProcessMutex mutex = getMutex(info);
    int tryTimes = info.getTryTimes();
    long tryInterval = info.getTryInterval();
    boolean flag = true;// 表明是否须要重试
    while (flag && --tryTimes >= 0) {
        try {
            if (mutex.acquire(info.getWaitLockTime(), TimeUnit.MILLISECONDS)) {
                LOGGER.info(LogConstant.DST_LOCK + "acquire lock successfully!");
                flag = false;
                break;
            }
        } catch (Exception e) {
            LOGGER.error(LogConstant.DST_LOCK + "acquire lock error!", e);
        } finally {
            checkAndRetry(flag, tryInterval, tryTimes);
        }
    }
    return !flag;// 最后还须要重试，说明没拿到锁
}

 

@Override
public boolean releaseLock(LockInfo info) {
    InterProcessMutex mutex = getMutex(info);
    int tryTimes = info.getTryTimes();
    long tryInterval = info.getTryInterval();
    boolean flag = true;// 表明是否须要重试
    while (flag && --tryTimes >= 0) {
        try {
            mutex.release();
            LOGGER.info(LogConstant.DST_LOCK + "release lock successfully!");
            flag = false;
            break;
        } catch (Exception e) {
            LOGGER.error(LogConstant.DST_LOCK + "release lock error!", e);
        } finally {
            checkAndRetry(flag, tryInterval, tryTimes);
        }
    }
    return !flag;// 最后还须要重试，说明没拿到锁
}

 

/**
     * 获取锁。此处须要加同步，concurrentHashmap没法避免此处的同步问题
     * @param info 锁信息
     * @return 锁实例
     */
    private synchronized InterProcessMutex getMutex(LockInfo info) {
        InterProcessReadWriteLock lock = null;
        if (locksCache.get(info.getLock()) != null) {
            lock = locksCache.get(info.getLock());
        } else {
            lock = new InterProcessReadWriteLock(client, BASE_DIR + info.getLock());
            locksCache.put(info.getLock(), lock);
        }
        InterProcessMutex mutex = null;
        switch (info.getIsolate()) {
        case READ:
            mutex = lock.readLock();
            break;
        case WRITE:
            mutex = lock.writeLock();
            break;
        default:
            throw new IllegalArgumentException();
        }
        return mutex;
    }

 

/**
 * 判断是否须要重试
 * @param flag 是否须要重试标志
 * @param tryInterval 重试间隔
 * @param tryTimes 重试次数
 */
private void checkAndRetry(boolean flag, long tryInterval, int tryTimes) {
    try {
        if (flag) {
            Thread.sleep(tryInterval);
            LOGGER.info(LogConstant.DST_LOCK + "retry getting lock! now retry time left: " + tryTimes);
        }
    } catch (InterruptedException e) {
        LOGGER.error(LogConstant.DST_LOCK + "retry interval thread interruptted!", e);
    }
}

 

2、memcached分布式锁

一、实现原理：

memcached带有add函数，利用add函数的特性便可实现分布式锁。add和set的区别在于：若是多线程并发set，则每一个set都会成功，但最后存储的值以最后的set的线程为准。而add的话则相反，add会添加第一个到达的值，并返回true，后续的添加则都会返回false。利用该点便可很轻松地实现分布式锁。

二、优势

并发高效。

三、缺点

（1）memcached采用列入LRU置换策略，因此若是内存不够，可能致使缓存中的锁信息丢失。

（2）memcached没法持久化，一旦重启，将致使信息丢失。

 

3、redis分布式锁

redis分布式锁便可以结合zk分布式锁锁高度安全和memcached并发场景下效率很好的优势，能够利用jedis客户端实现。