不用找了，基于 Redis 的分布式锁实战来了！

SET resource_name my_random_value NX PX 30000  
 手动删除锁（Lua脚本）：  
if redis.call("get",KEYS[1]) == ARGV[1] then  
    return redis.call("del",KEYS[1])  
else  
    return 0  
end  

package com.caiya.cms.web.component;  
import com.caiya.cache.CacheException;  
import com.caiya.cache.redis.JedisCache;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import java.util.Objects;  
import java.util.concurrent.TimeUnit;  
/**  
 * redis实现分布式锁  
 * 可实现特性:  
 * 1、使多线程无序排队获取和释放锁;  
 * 2、丢弃未成功获得锁的线程处理;  
 * 3、只释放线程本身加持的锁;  
 * 4、避免死锁  
 *  
 * @author wangnan  
 * @since 1.0  
 */  
public final class RedisLock {  
    private static final Logger logger = LoggerFactory.getLogger(RedisLock.class);  
    /**  
     * 尝试加锁(仅一次)  
     *  
     * @param lockKey       锁key  
     * @param lockValue     锁value  
     * @param expireSeconds 锁超时时间(秒)  
     * @return 是否加锁成功  
     * @throws CacheException  
     */  
    public static boolean tryLock(String lockKey, String lockValue, long expireSeconds) throws CacheException {  
        JedisCache jedisCache = JedisCacheFactory.getInstance().getJedisCache();  
        try {  
            String response = jedisCache.set(lockKey, lockValue, "nx", "ex", expireSeconds);  
            return Objects.equals(response, "OK");  
        } finally {  
            jedisCache.close();  
        }  
    }  
    /**  
     * 加锁(指定最大尝试次数范围内)  
     *  
     * @param lockKey       锁key  
     * @param lockValue     锁value  
     * @param expireSeconds 锁超时时间(秒)  
     * @param tryTimes      最大尝试次数  
     * @param sleepMillis   每两次尝试之间休眠时间(毫秒)  
     * @return 是否加锁成功  
     * @throws CacheException  
     */  
    public static boolean lock(String lockKey, String lockValue, long expireSeconds, int tryTimes, long sleepMillis) throws CacheException {  
        boolean result;  
        int count = 0;  
        do {  
            count++;  
            result = tryLock(lockKey, lockValue, expireSeconds);  
            try {  
                TimeUnit.MILLISECONDS.sleep(sleepMillis);  
            } catch (InterruptedException e) {  
                logger.error(e.getMessage(), e);  
            }  
        } while (!result && count <= tryTimes);  
        return result;  
    }  
    /**  
     * 释放锁  
     *  
     * @param lockKey   锁key  
     * @param lockValue 锁value  
     */  
    public static void unlock(String lockKey, String lockValue) {  
        JedisCache jedisCache = JedisCacheFactory.getInstance().getJedisCache();  
        try {  
            String luaScript = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end";  
            Object result = jedisCache.eval(luaScript, 1, lockKey, lockValue);  
//            Objects.equals(result, 1L);  
        } catch (Exception e) {  
            logger.error(e.getMessage(), e);  
        } finally {  
            jedisCache.close();  
        }  
//        return false;  
    }  
    private RedisLock() {  
    }  
}  

        ...  
        String lockKey = Constant.DEFAULT_CACHE_NAME + ":addItemApply:" + applyPriceDTO.getItemId() + "_" + applyPriceDTO.getSupplierId();// 跟业务相关的唯一拼接键  
        String lockValue = Constant.DEFAULT_CACHE_NAME + ":" + System.getProperty("JvmId") + ":" + Thread.currentThread().getName() + ":" + System.currentTimeMillis();// 生成集群环境中的唯一值  
        boolean locked = RedisLock.tryLock(lockKey, lockValue, 100);// 只尝试一次，在本次处理过程中直接拒绝其他线程的请求  
        if (!locked) {  
            throw new IllegalAccessException("您的操作太频繁了,休息一下再来吧~");  
        }  
        try {  
            // 开始处理核心业务逻辑  
            Item item = itemService.queryItemByItemId(applyPriceDTO.getItemId());  
            ...  
            ...  
        } finally {  
            RedisLock.unlock(lockKey, lockValue);// 在finally块中释放锁  
        }  

        ...  
        String lockKey = Constant.DEFAULT_CACHE_NAME + ":addItemApply:" + applyPriceDTO.getItemId() + "_" + applyPriceDTO.getSupplierId();  
        String lockValue = Constant.DEFAULT_CACHE_NAME + ":机器编号:" + Thread.currentThread().getName() + ":" + System.currentTimeMillis();  
        boolean locked = RedisLock.lock(lockKey, lockValue, 100, 20, 100);// 非公平锁，无序竞争（这里需要合理根据业务处理情况设置最大尝试次数和每次休眠时间）  
        if (!locked) {  
            throw new IllegalAccessException("系统太忙,本次操作失败");// 一般来说，不会走到这一步；如果真的有这种情况，并且在合理设置锁尝试次数和等待响应时间之后仍然处理不过来，可能需要考虑优化程序响应时间或者用消息队列排队执行了  
        }  
        try {  
            // 开始处理核心业务逻辑  
            Item item = itemService.queryItemByItemId(applyPriceDTO.getItemId());  
            ...  
            ...  
        } finally {  
            RedisLock.unlock(lockKey, lockValue);  
        }  
        ...