spring redis 分布式锁

概要：

Redis因为是单线程的，所以本身没有锁的概念。

所以分布式锁的实现原理是往Redis当中写入一个key(调用方法setnx)，写入成功相当于获取锁成功。写入失败也即是setnx方法返回0，获取锁失败。

注意锁的失效时间，否则容易造成死锁。

官方原理图:

说明:

       由于分布式系统的时间不一定完全一样,所以本例子没有使用时间戳作为超时的判断,使用的是redis的setEx来设置超时时间

防止出现死锁的现象.

死锁产生的可能是其中一台服务器获取锁后异常中断,但并未释放锁,设置一个超时时间,可以解决.

代码如下:

1.Lock类

package com.example.util;

/**
 * 全局锁，包括锁的名称
 * Created by lp on 2017/5/9.
 */
public class Lock {

    private String name;
    private String value;


    public Lock(String name, String value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

2.DistributeLockHandler类

package com.example.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.concurrent.TimeUnit;

/**
 * Created by lp on 2017/5/9.
 */
@Component
public class DistributedLockHandler {


    private static final Logger logger = LoggerFactory.getLogger(DistributedLockHandler.class);

    private final static long LOCK_EXPIRE = 20 * 1000L; //单个业务持有锁的时间30s,防止死锁

    private final static long LOCK_TRY_INTERVAL = 30L; //默认30ms尝试一次

    private final static long LOCK_TRY_TIMEOUT = 30 * 1000L; // 默认尝试30s

    @Autowired
    private StringRedisTemplate template;

    /**
     * 操作redis获取全局锁
     *
     * @param lock           锁的名称
     * @param timeout        获取的超时时间
     * @param tryInterval    多少ms尝试一次
     * @param lockExpireTime 获取成功后锁的过期时间
     * @return true 获取成功，false获取失败
     */
    public boolean  getLock(Lock lock,long timeout,long tryInterval,long lockExpireTime){

        try{
            if(StringUtils.isEmpty(lock.getName()) || StringUtils.isEmpty(lock.getValue())){
                return false;
            }
            long startTime = System.currentTimeMillis();
            while (true){
                if(template.opsForValue().setIfAbsent(lock.getName(),lock.getValue())){
                    template.opsForValue().set(lock.getName(),lock.getValue(),lockExpireTime,TimeUnit.MILLISECONDS);
                    logger.info(Thread.currentThread().getName() + " : get lock");
                    return true;
                }else {
                    logger.info(Thread.currentThread().getName() + " : ----> locking is exist!!!");
                }
                if(System.currentTimeMillis() - startTime > timeout){
                    return false;
                }
                Thread.sleep(tryInterval);
            }
        }catch (Exception e){
            logger.error(e.getMessage());
            return false;
        }
    }


    /**
     * 尝试获取全局锁
     *
     * @param lock 锁的名称
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock) {
        return getLock(lock, LOCK_TRY_TIMEOUT, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
    }


    /**
     * 尝试获取全局锁
     *
     * @param lock    锁的名称
     * @param timeout 获取超时时间 单位ms
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock, long timeout) {
        return getLock(lock, timeout, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
    }


    /**
     * 尝试获取全局锁
     *
     * @param lock        锁的名称
     * @param timeout     获取锁的超时时间
     * @param tryInterval 多少毫秒尝试获取一次
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock, long timeout, long tryInterval) {
        return getLock(lock, timeout, tryInterval, LOCK_EXPIRE);
    }


    /**
     * 尝试获取全局锁
     *
     * @param lock           锁的名称
     * @param timeout        获取锁的超时时间
     * @param tryInterval    多少毫秒尝试获取一次
     * @param lockExpireTime 锁的过期
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock, long timeout, long tryInterval, long lockExpireTime) {
        return getLock(lock, timeout, tryInterval, lockExpireTime);
    }






    /**
     * 释放锁
     */
    public void releaseLock(Lock lock) {
        if (!StringUtils.isEmpty(lock.getName())) {
            logger.info(Thread.currentThread().getName() + " : del lock");
            template.delete(lock.getName());
        }
    }



}

3.DistributedService 类

package com.example.service;

import com.example.util.DistributedLockHandler;
import com.example.util.Lock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Created by lp on 2017/5/10.
 */
@Service
public class DistributedService {


    private static final Logger logger = LoggerFactory.getLogger(DistributedLockHandler.class);

    @Autowired
    private DistributedLockHandler distributedLockHandler;

    final Lock lock = new Lock("BIZ:LOCK:TEST", "BIZ:LOCK:TEST");


    public synchronized void doDistribute(){
        if (distributedLockHandler.tryLock(lock)) {

            logger.info(Thread.currentThread().getName() + " : do something");
            try {
                Thread.sleep(10000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            distributedLockHandler.releaseLock(lock);

        }
    }


}