基于Redis的分布式锁实现

        线程锁:大家都不陌生，主要用来给方法、代码块加锁。当某个方法或者代码块使用锁时，那么在同一时刻至多仅有有一个线程在执行该段代码。当有多个线程访问同一对象的加锁方法/代码块时，同一时间只有一个线程在执行，其余线程必须要等待当前线程执行完之后才能执行该代码段。但是，其余线程是可以访问该对象中的非加锁代码块的。

　　进程锁:也是为了控制同一操作系统中多个进程访问一个共享资源，只是因为程序的独立性，各个进程是无法控制其他进程对资源的访问的，但是可以使用本地系统的信号量控制（操作系统基本知识）。

　　分布式锁:当多个进程不在同一个系统之中时，使用分布式锁控制多个进程对资源的访问

 

接下来基于redis实现分布式锁，一般用redis实现分布式锁有多种不同的方式，平时开发人员用得比较多的是SETNX和INCR等

先贴出RedisUtils:

package com.pinyu.miniprogram.config.redis;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

/**
 * @author ypp 创建时间：2018年11月19日 下午4:58:04
 * @Description: TODO(redis缓存工具类)
 */
@Component
public class RedisUtils {

	@Autowired
	@Qualifier("redisTemplate")
	private RedisTemplate<String, Object> redisTemplate;

	// =============================common============================
	/**
	 * 指定缓存失效时间
	 * @param key 键
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean expire(String key, long time) {
		try {
			if (time > 0) {
				redisTemplate.expire(key, time, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据key 获取过期时间
	 * @param key 键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}

	/**
	 * 判断key是否存在
	 * @param key 键
	 * @return true 存在 false不存在
	 */
	public boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除缓存
	 * @param key 可以传一个值 或多个
	 */
	@SuppressWarnings("unchecked")
	public void del(String... key) {
		if (key != null && key.length > 0) {
			if (key.length == 1) {
				redisTemplate.delete(key[0]);
			} else {
				redisTemplate.delete(CollectionUtils.arrayToList(key));
			}
		}
	}

	// ============================String=============================
	/**
	 * 普通缓存获取
	 * @param key 键
	 * @return 值
	 */
	public Object get(String key) {
		return key == null ? null : redisTemplate.opsForValue().get(key);
	}

	/**
	 * 普通缓存放入
	 * @param key 键
	 * @param value 值
	 * @return true成功 false失败
	 */
	public boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}

	/**
	 * 普通缓存放入并设置时间
	 * 
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public boolean set(String key, Object value, long time) {
		try {
			if (time > 0) {
				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
			} else {
				set(key, value);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 递增
	 * @param key 键
	 * @param by 要增加几(大于0)
	 * @return
	 */
	public long incr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递增因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, delta);
	}

	/**
	 * 递减
	 * @param key 键
	 * @param by 要减少几(小于0)
	 * @return
	 */
	public long decr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, -delta);
	}

	// ================================Map=================================
	/**
	 * HashGet
	 * @param key 键 不能为null
	 * @param item 项 不能为null
	 * @return 值
	 */
	public Object hget(String key, String item) {
		return redisTemplate.opsForHash().get(key, item);
	}

	/**
	 * 获取hashKey对应的所有键值
	 * @param key 键
	 * @return 对应的多个键值
	 */
	public Map<Object, Object> hmget(String key) {
		return redisTemplate.opsForHash().entries(key);
	}

	/**
	 * HashSet
	 * @param key 键
	 * @param map 对应多个键值
	 * @return true 成功 false 失败
	 */
	public boolean hmset(String key, Map<String, Object> map) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * HashSet 并设置时间
	 * @param key 键
	 * @param map 对应多个键值
	 * @param time 时间(秒)
	 * @return true成功 false失败
	 */
	public boolean hmset(String key, Map<String, Object> map, long time) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * @param key 键
	 * @param item 项
	 * @param value 值
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * @param key 键
	 * @param item 项
	 * @param value 值
	 * @param time
	 *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value, long time) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除hash表中的值
	 * @param key 键 不能为null
	 * @param item 项 可以使多个 不能为null
	 */
	public void hdel(String key, Object... item) {
		redisTemplate.opsForHash().delete(key, item);
	}

	/**
	 * 判断hash表中是否有该项的值
	 * @param key 键 不能为null
	 * @param item 项 不能为null
	 * @return true 存在 false不存在
	 */
	public boolean hHasKey(String key, String item) {
		return redisTemplate.opsForHash().hasKey(key, item);
	}

	/**
	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
	 * @param key 键
	 * @param item 项
	 * @param by 要增加几(大于0)
	 * @return
	 */
	public double hincr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, by);
	}

	/**
	 * hash递减
	 * @param key 键
	 * @param item 项
	 * @param by 要减少记(小于0)
	 * @return
	 */
	public double hdecr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, -by);
	}

	// ============================set=============================
	/**
	 * 根据key获取Set中的所有值
	 * @param key 键
	 * @return
	 */
	public Set<Object> sGet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 根据value从一个set中查询,是否存在
	 * @param key 键
	 * @param value 值
	 * @return true 存在 false不存在
	 */
	public boolean sHasKey(String key, Object value) {
		try {
			return redisTemplate.opsForSet().isMember(key, value);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将数据放入set缓存
	 * @param key 键
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSet(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 将set数据放入缓存
	 * @param key 键
	 * @param time 时间(秒)
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSetAndTime(String key, long time, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().add(key, values);
			if (time > 0)
				expire(key, time);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取set缓存的长度
	 * @param key 键
	 * @return
	 */
	public long sGetSetSize(String key) {
		try {
			return redisTemplate.opsForSet().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 移除值为value的
	 * @param key 键
	 * @param values 值 可以是多个
	 * @return 移除的个数
	 */
	public long setRemove(String key, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().remove(key, values);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
	// ===============================list=================================

	/**
	 * 获取list缓存的内容
	 * 
	 * @param key 键
	 * @param start 开始
	 * @param end 结束 0 到 -1代表所有值
	 * @return
	 */
	public List<Object> lGet(String key, long start, long end) {
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取list缓存的长度
	 * @param key 键
	 * @return
	 */
	public long lGetListSize(String key) {
		try {
			return redisTemplate.opsForList().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 通过索引 获取list中的值
	 * @param key 键
	 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * @return
	 */
	public Object lGetIndex(String key, long index) {
		try {
			return redisTemplate.opsForList().index(key, index);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value, long time) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			if (time > 0)
				expire(key, time);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * @param key 键
	 * @param value 值
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value, long time) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			if (time > 0)
				expire(key, time);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据索引修改list中的某条数据
	 * @param key 键
	 * @param index 索引
	 * @param value 值
	 * @return
	 */
	public boolean lUpdateIndex(String key, long index, Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 移除N个值为value
	 * @param key 键
	 * @param count 移除多少个
	 * @param value 值
	 * @return 移除的个数
	 */
	public long lRemove(String key, long count, Object value) {
		try {
			Long remove = redisTemplate.opsForList().remove(key, count, value);
			return remove;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
	/**
	 * 添加一个元素, zset与set最大的区别就是每个元素都有一个score，因此有个排序的辅助功能;  zadd
	 *
	 * @param key
	 * @param value
	 * @param score
	 */
	public boolean zsetAdd(String key, Object value, Double score) {
		try {
			redisTemplate.opsForZSet().add(key, value,score);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	/**
	 * 删除元素 zrem
	 *
	 * @param key
	 * @param value
	 */
	public void remove(String key, String value) {
	    redisTemplate.opsForZSet().remove(key, value);
	}
	
	/**
	 * @param key
	 * @param value
	 * @param score
	 */
	public Double incrScore(String key, String value, double score) {
	    return redisTemplate.opsForZSet().incrementScore(key, value, score);
	}
	
	/**
	 * 查询value对应的score   zscore
	 *
	 * @param key
	 * @param value
	 * @return
	 */
	public Double score(String key, String value) {
	    return redisTemplate.opsForZSet().score(key, value);
	}
	
	/**
	 * 判断value在zset中的排名  zrank
	 *
	 * @param key
	 * @param value
	 * @return
	 */
	public Long rank(String key, String value) {
	    return redisTemplate.opsForZSet().rank(key, value);
	}
	
	/**
	 * 返回集合的长度
	 *
	 * @param key
	 * @return
	 */
	public Long size(String key) {
	    return redisTemplate.opsForZSet().zCard(key);
	}
	
	/**
	 * 查询集合中指定顺序的值， 0 -1 表示获取全部的集合内容  zrange
	 *
	 * 返回有序的集合，score小的在前面
	 *
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public Set<Object> range(String key, int start, int end) {
	    return redisTemplate.opsForZSet().range(key, start, end);
	}
	/**
	 * setNX
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean  setNx(String key,Object value){
		return redisTemplate.opsForValue().setIfAbsent(key, value);
	}
	
	/**
	 * 设置setnx的过期时间 毫秒单位
	 * @param key
	 * @param value
	 * @param milliseconds
	 * @return
	 */
	public boolean  setNx(String key,Object value,Long milliseconds){
		return redisTemplate.opsForValue().setIfAbsent(key, value,milliseconds,TimeUnit.MILLISECONDS);
	}

}

假如库存现在是10

最原始的代码:

@RequestMapping("/stock")
	public String setnx() throws InterruptedException {
		Integer stock = (Integer)redisUtils.get("stock");//获取库存
		if(stock>0){
			stock=stock-1;
			redisUtils.set("stock",stock);
			System.out.println("剩余库存:"+stock);
		}else {
			System.out.println("抢购失败,已被抢完,下次请早点");
		}
		return JsonMsg.OK();
	}

使用JMeter模仿同时并发1000请求

可以看到，数据完全错乱,出现了多个请求并发操作

使用setnx加锁:

@RequestMapping("/stock")
	public void setnx() throws InterruptedException {
		boolean b = acquire();//获取锁
		if(b){
			Integer stock = (Integer)redisUtils.get("stock");//获取库存
			if(stock>0){
				stock=stock-1;
				redisUtils.set("stock",stock);
				System.out.println("剩余库存:"+stock);
			}else {
				System.out.println("抢购失败,已被抢完,下次请早点");
			}
			//释放锁
			redisUtils.del("lock");
		}else {
			return;
		}
	}
	
	public boolean acquire(){
		return redisUtils.setNx("lock","lockValue");
		
	}

 

 还是存在问题，如果在执行库存中途异常了,导致后面代码不执行，锁一致是无法释放，其他线程一直拿不到锁，导致死锁。需要保证无论如何最后锁是要放开的。try()finally{}

@RequestMapping("/stock")
	public void setnx() throws InterruptedException {
		boolean b = acquire();//获取锁
		if(b){
			try {
				Integer stock = (Integer)redisUtils.get("stock");//获取库存
				if(stock>0){
					stock=stock-1;
					redisUtils.set("stock",stock);
					System.out.println("剩余库存:"+stock);
				}else {
					System.out.println("抢购失败,已被抢完,下次请早点");
				}
			} finally {
				//释放锁
				redisUtils.del("lock");
			}
		}
	}
	
	
	public boolean acquire(){
		return redisUtils.setNx("lock","lockValue");
		
	}

以上还是有问题，比如释放锁失败了，释放锁失败的情况很多种，比如应用挂了等,还是会导致死锁。解决办法可以在加锁的时候设置锁的过期时间(根据自己业务逻辑代码可能执行的时间，比如库存操作最长操作)

继续改造代码:

@RequestMapping("/stock")
	public void setnx() throws InterruptedException {
		boolean b = acquire();//获取锁
		if(b){
			try {
				Integer stock = (Integer)redisUtils.get("stock");//获取库存
				if(stock>0){
					stock=stock-1;
					redisUtils.set("stock",stock);
					System.out.println("剩余库存:"+stock);
				}else {
					System.out.println("抢购失败,已被抢完,下次请早点");
				}
			} finally {
				//释放锁
				redisUtils.del("lock");
			}
		}
	}
	
	
	public boolean acquire(String lock,String clientID){
		return redisUtils.setNx(lock,clientID,10000L);//10秒过期,其实是两步操作，设置lock和设置过期时间，redis保证原子性，要么都成功，要么都失败。如果分加锁和设置超时时间两步操作，那么在加锁后突然挂了，也有可能依然导致死锁
	}

到这里很多开发人员基本就到此为止了。其实还有缺陷,如果线程1在库存业务逻辑超过了10秒，锁已经过期，线程2进来又进行加锁，在线程1业务逻辑执行完之后去释放锁，其实释放的就是线程2的锁，在高并发场景会导致锁混乱甚至锁永久失效，对于大型的互联网的公司是一个非常非常严重的bug，导致订单数据错乱，无法发货等。

解决办法多种多样，保证每个线程释放的是自己的锁

继续改造:

@RequestMapping("/stock")
	public void setnx() throws InterruptedException {
		String lock="lock";
		String clientID = UUID.randomUUID().toString();//拥有自己锁id
		boolean b = acquire(lock,clientID);//获取锁
		if(b){
			try {
				Integer stock = (Integer)redisUtils.get("stock");//获取库存
				if(stock>0){
					stock=stock-1;
					redisUtils.set("stock",stock);
					System.out.println("剩余库存:"+stock);
				}else {
					System.out.println("抢购失败,已被抢完,下次请早点");
				}
			} finally {
				//释放锁,确保释放的是自己加的锁
				if(clientID.equals(redisUtils.get(lock))){
					redisUtils.del(lock);
				}
			}
		}else {
			return;
		}
	}
	
	public boolean acquire(String lock,String clientID){
		return redisUtils.setNx(lock,clientID,10000L);//10秒过期,其实是两步操作，设置lock和设置过期时间，redis保证原子性，要么都成功，要么都失败。如果分加锁和设置超时时间两步操作，那么在加锁后突然挂了，也有可能依然导致死锁
	}

按照以上代码还是会有小bug，当业务逻辑执行到10秒后，线程1锁已经过期，其他某个线程进来，是可以进行加锁的。就意味着可能有多个线程会同时在执行库存操作。那将锁延时？在线程1加锁之后，在执行业务逻辑的时候每隔一定时间去进行再次延时锁的时间来保证其他线程不会拿到锁。解决了这个问题之后分布式锁算是比较完美了！可重入锁

实现可重入锁的方式也多种，建议如果有第三方好的方案就不要自己写，说不定倒写出一些bug出来。

Redisson:

继续之上的代码修改:

添加pom.xml

<dependency>
      <groupId>org.redisson</groupId>
      <artifactId>redisson</artifactId>
      <version>3.8.2</version>
</dependency>

RedissonConfig:

package com.pinyu.miniprogram.config.redisson;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.ReadMode;
import org.redisson.config.SentinelServersConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {

	@Value("${spring.redis.sentinel.master}")
	private String master;
	
	@Value("${spring.redis.sentinel.nodes}")
	private String redisNodes;
	
	@Value("${spring.redis.password}")
	private String password;
	
	@Value("${spring.redis.timeout}")
	private Integer timeout;
	
	/**  
     * 哨兵模式 redisson 客户端
     * @return
     */

    @Bean
    RedissonClient redissonSentinel() {
        Config config = new Config();
        String[] nodes = redisNodes.split(",");
        List<String> newNodes = new ArrayList(nodes.length);
        Arrays.stream(nodes).forEach((index) -> newNodes.add(index.startsWith("redis://") ? index : "redis://" + index));

        SentinelServersConfig serverConfig = config.useSentinelServers()
                .addSentinelAddress(newNodes.toArray(new String[0]))
                .setMasterName(master)
                .setReadMode(ReadMode.SLAVE)
                .setTimeout(timeout);
//                .setMasterConnectionPoolSize(redisPoolSize)
//                .setSlaveConnectionPoolSize(redisPoolSize);

        if (StringUtils.isNotBlank(password)) {
            serverConfig.setPassword(password);
        }

        return Redisson.create(config);
    }
}

application.yml:

server: 
  port: 8081
  # 下面是配置undertow作为服务器的参数
  undertow: 
    # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
    io-threads: 4
    # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
    worker-threads: 20
    # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
    # 每块buffer的空间大小,越小的空间被利用越充分
    buffer-size: 1024
    # 是否分配的直接内存
    direct-buffers: true
    
#启用shutdown
#endpoints: 
 # shutdown: 
   # enable: true
#禁用密码验证
#endpoints: 
  #shutdown: 
    #sensitive: false
#linux关闭的脚本
#curl -X POST host:port/shutdown

#开启shutdown的安全验证
#endpoints: 
  #shutdown: 
    #sensitive: true
    
#验证用户名和密码
#security: 
  #user: 
    #name: admin
    #password: admin
    
#角色
#management: 
  #address: 127.0.0.1
  #port: 8081
  #security: 
    #role: SUPERUSER


spring: 
  http:
    encoding:
      force: true
  datasource: 
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    driver-class-name: com.mysql.cj.jdbc.Driver
    platform: mysql
    url: jdbc:mysql://xx.xxx.xxx.xx:5306/miniprogram?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false
    username: root
    password: admin
# ELASTICSEARCH (ElasticsearchProperties)
# Elasticsearch cluster name.
#  data:
#    elasticsearch:
#      cluster-name: elasticsearch
#      cluster-nodes: 192.168.13.111:9300,192.168.13.222:9300
#      repositories:
#        enabled: true
  redis: 
#    database: 1
    host: 127.0.0.1
    port: 6379
    password: 
    timeout: 10000
    lettuce:
          pool:
            minIdle: 0
            maxIdle: 10
            maxWait: 10000
            max-active: 10
    sentinel:
      master: master-6379
      nodes: 127.0.0.1:26379,127.0.0.1:26380,127.0.0.1:26381
#    cluster:
#      nodes:
#        - 192.168.91.5:9001
#        - 192.168.91.5:9002
#        - 192.168.91.5:9003
#        - 192.168.91.5:9004
#        - 192.168.91.5:9005
#        - 192.168.91.5:9006
  activemq: 
    queueName: mvp.queue
    topicName: mvp.topic
    #账号密码
    user: user
    password: user
    #URL of the ActiveMQ broker.
    broker-url: tcp://localhost:61616
    in-memory: false
    #必须使用连接池
    pool: 
      #启用连接池
      enabled: true
      #连接池最大连接数
      max-connections: 5
      #空闲的连接过期时间，默认为30秒
      idle-timeout: 30s
    
mybatis: 
  typeAliasesPackage: com.pinyu.miniprogram.mysql.entity
  mapper-locations: classpath:mapper/**/*Mapper.xml
mapper:
  mappers: com.pinyu.miniprogram.mysql.mappers.BaseMapper
  identity: mysql
  
  
#logging.config: 
#  classpath: test/log4j2_test.xml

改造后的代码:

@Autowired
	private RedissonClient redissonClient;

	@RequestMapping("/stock")
	public void setnx() throws InterruptedException {
		String lock = "lock";
		RLock rLock = redissonClient.getLock(lock);
		try {
			rLock.lock();//加锁
			Integer stock = (Integer) redisUtils.get("stock");// 获取库存
			if (stock > 0) {
				stock = stock - 1;
				redisUtils.set("stock", stock);
				System.out.println("剩余库存:" + stock);
			} else {
				System.out.println("抢购失败,已被抢完,下次请早点");
			}
		} finally {
			// 释放锁
			rLock.unlock();
		}
	}

以上代码几乎0bug，也是使用第三方框架的好处,redisson底层也是操作的redis

测试:

将库存多加点到100，并发2000请求看看

完成