<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>

  <!-- 開(kāi)啟web-->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  
  <!-- redis-->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

/**
 * 全局鎖，包括鎖的名稱(chēng)
 * Created by fangzhipeng on 2017/4/1.
 */
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 String getValue() {
        return value;
    }
}

import org.apache.commons.lang.StringUtils;
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.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * Created by fangzhipeng on 2017/4/1.
 */
@Component
public class DistributedLockHandler {

    private static final Logger logger = LoggerFactory.getLogger(DistributedLockHandler.class);
    private final static long LOCK_EXPIRE = 30 * 1000L;//單個(gè)業(yè)務(wù)持有鎖的時(shí)間30s，防止死鎖
    private final static long LOCK_TRY_INTERVAL = 30L;//默認(rèn)30ms嘗試一次
    private final static long LOCK_TRY_TIMEOUT = 20 * 1000L;//默認(rèn)嘗試20s

    @Autowired
    private StringRedisTemplate template;

    /**
     * 嘗試獲取全局鎖
     *
     * @param lock 鎖的名稱(chēng)
     * @return true 獲取成功，false獲取失敗
     */
    public boolean tryLock(Lock lock) {
        return getLock(lock, LOCK_TRY_TIMEOUT, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
    }

    /**
     * 嘗試獲取全局鎖
     *
     * @param lock    鎖的名稱(chēng)
     * @param timeout 獲取超時(shí)時(shí)間 單位ms
     * @return true 獲取成功，false獲取失敗
     */
    public boolean tryLock(Lock lock, long timeout) {
        return getLock(lock, timeout, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
    }

    /**
     * 嘗試獲取全局鎖
     *
     * @param lock        鎖的名稱(chēng)
     * @param timeout     獲取鎖的超時(shí)時(shí)間
     * @param tryInterval 多少毫秒嘗試獲取一次
     * @return true 獲取成功，false獲取失敗
     */
    public boolean tryLock(Lock lock, long timeout, long tryInterval) {
        return getLock(lock, timeout, tryInterval, LOCK_EXPIRE);
    }

    /**
     * 嘗試獲取全局鎖
     *
     * @param lock           鎖的名稱(chēng)
     * @param timeout        獲取鎖的超時(shí)時(shí)間
     * @param tryInterval    多少毫秒嘗試獲取一次
     * @param lockExpireTime 鎖的過(guò)期
     * @return true 獲取成功，false獲取失敗
     */
    public boolean tryLock(Lock lock, long timeout, long tryInterval, long lockExpireTime) {
        return getLock(lock, timeout, tryInterval, lockExpireTime);
    }


    /**
     * 操作redis獲取全局鎖
     *
     * @param lock           鎖的名稱(chēng)
     * @param timeout        獲取的超時(shí)時(shí)間
     * @param tryInterval    多少ms嘗試一次
     * @param lockExpireTime 獲取成功后鎖的過(guò)期時(shí)間
     * @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();
            do{
                if (!template.hasKey(lock.getName())) {
                    ValueOperations<String, String> ops = template.opsForValue();
                    ops.set(lock.getName(), lock.getValue(), lockExpireTime, TimeUnit.MILLISECONDS);
                    return true;
                } else {//存在鎖
                    logger.debug("lock is exist!??！");
                }
                if (System.currentTimeMillis() - startTime > timeout) {//嘗試超過(guò)了設(shè)定值之后直接跳出循環(huán)
                    return false;
                }
                Thread.sleep(tryInterval);
            }
            while (template.hasKey(lock.getName())) ;
        } catch (InterruptedException e) {
            logger.error(e.getMessage());
            return false;
        }
        return false;
    }

    /**
     * 釋放鎖
     */
    public void releaseLock(Lock lock) {
        if (!StringUtils.isEmpty(lock.getName())) {
            template.delete(lock.getName());
        }
    }
}

@Autowired
DistributedLockHandler distributedLockHandler;
Lock lock=new Lock("lockk","sssssssss);
if(distributedLockHandler.tryLock(lock){
 doSomething();
 distributedLockHandler.releaseLock();
}