Redis分布式锁与淘汰机制

什么是分布式锁

• 多个服务间保证同一时刻同一时间段内同一用户只能有一个请求(防止关键业务出现并发攻击)

案例

• 新建两个model：boot_redis01，boot_redis02

• pom

• org.springframework.boot
  spring-boot-starter-web
            
       
  org.springframework.boot
  spring-boot-starter-actuator
            
  org.springframework.boot
  spring-boot-starter-data-redis
            
  org.apache.commons
  commons-pool2
            
  redis.clients
  jedis
  3.1.0
            
  org.springframework.boot
  spring-boot-starter-aop
            
  org.redisson
  redisson
  3.13.4
            
  org.springframework.boot
  spring-boot-devtools
  runtime
  true
            
  org.projectlombok
  lombok
  true
            
  junit
  junit
  4.12
  

• yml

• server.port=1111
    
  spring.redis.database=0
  spring.redis.host=
  spring.redis.port=6379
  #连接池最大连接数（使用负值表示没有限制）默认8
  spring.redis.lettuce.pool.max-active=8
  #连接池最大阻塞等待时间（使用负值表示没有限制）默认-1
  spring.redis.lettuce.pool.max-wait=-1
  #连接池中的最大空闲连接默认8
  spring.redis.lettuce.pool.max-idle=8
  #连接池中的最小空闲连接默认0
  spring.redis.lettuce.pool.min-idle=0
  

• 启动类

• @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
  public class BootRedis01Application {
  	public static void main(String[] args) {
          SpringApplication.run(BootRedis01Application.class);
  	}
  }
  

• 配置类

• @Configuration
  public class RedisConfig {
    
  	/**
   	* 保证不是序列化后的乱码配置
  	*/
  	@Bean
  	public RedisTemplate, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory)	{
          RedisTemplate, Serializable> redisTemplate = new RedisTemplate();
  		redisTemplate.setKeySerializer(new StringRedisSerializer());
  		redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
  		redisTemplate.setConnectionFactory(connectionFactory);
          return redisTemplate;
  	}
  }
  

• 业务类

• @RestController
  public class GoodController {
    
  	@Autowired
  	private StringRedisTemplate stringRedisTemplate;
    
  	@Value("${server.port}")
  	private String serverPort;
    
  	@GetMapping("/buy_goods")
  	public String buy_Goods(){
    
          String result = stringRedisTemplate.opsForValue().get("goods:001");
          int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
          if (goodsNumber > 0){
  		int realNumber = goodsNumber - 1;
  		stringRedisTemplate.opsForValue().set("goods:001",realNumber + "");
  		System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件"+"\t 服务器端口: 		"+serverPort);
              return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件"+"\t 服务器端口: "+serverPort;
  		}else {
              System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临"+"\t 服务器端口: 				"+serverPort);
  		}
  		return "商品已经售罄/活动结束/调用超时，欢迎下次光临"+"\t 服务器端口: "+serverPort;
  	}
    
  }
  

• 测试

• 

单机版没加锁

• 问题：没有加锁，并发下数字不对，出现超卖现象

• 思考

  • 加synchronized

  • 加ReentrantLock

  • @RestController
    public class GoodController {
        
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
        
        @Value("${server.port}")
        private String serverPort;
        
        private final Lock lock = new ReentrantLock();
        
        @GetMapping("/buy_goods")
        public String buy_Goods() {
        
            if (lock.tryLock()) {
                try {
                    String result = stringRedisTemplate.opsForValue().get("goods:001");
                    int goodsNumber = result == null ? 0 : Integer.parseInt(result);
                    if (goodsNumber > 0) {
                        int realNumber = goodsNumber - 1;
                        stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                        System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
                        return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
                    }
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
            }
            return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
        }
        
    }
    

• 修改后版本

• @RestController
  public class GoodController {
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
          synchronized(this) {
              String result = stringRedisTemplate.opsForValue().get("goods:001");
              int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
              if (goodsNumber > 0) {
                  int realNumber = goodsNumber - 1;
                  stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                  System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
                  return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
              } else {
                  System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
              }
              return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
          }
      }
  }
  

• 在单机环境下，可以使用synchronized或Lock来实现。但是在分布式系统中，因为竞争的线程可能不在同一个节点上(同一个jvm中），所以需要一个让所有进程都能访问到的锁来实现，比如redis或者zookeeper来构建;不同进程jvm层面的锁就不管用了，那么可以利用第三方的一个组件，来获取锁，未获取到锁，则阻塞当前想要运行的线程

nginx分布式微服务架构

• 分布式部署后，单机锁还是出现超卖现象，需要分布式锁

• Redis具有极高的性能，且其命令对分布式锁支持友好，借助SET命令即可实现加锁处理.

• 加入nginx，实现负载均衡

• 

• 修改后版本

• @RestController
  public class GoodController {
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
          //setIfAbsent() 就是如果不存在就新建
          Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value); //setnx
    
          if (!lockFlag) {
              return "抢锁失败，┭┮﹏┭┮";
          } else {
              String result = stringRedisTemplate.opsForValue().get("goods:001");
              int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
              if (goodsNumber > 0) {
                  int realNumber = goodsNumber - 1;
                  stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                  System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
                  stringRedisTemplate.delete(REDIS_LOCK_KEY); //释放锁
                  return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
              } else {
                  System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
              }
              return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
          }
      }
  }
  

异常无法释放锁

• 出异常的话，可能无法释放锁， 必须要在代码层面finally释放锁

• 加锁解锁，lock/unlock必须同时出现并保证调用

• 修改后版本

• @RestController
  public class GoodController {
    
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
          try {
              //setIfAbsent() 就是如果不存在就新建
              Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value); //setnx
    
              if (!lockFlag) {
                  return "抢锁失败，┭┮﹏┭┮";
              } else {
                  String result = stringRedisTemplate.opsForValue().get("goods:001");
                  int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
                  if (goodsNumber > 0) {
                      int realNumber = goodsNumber - 1;
                      stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                      System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
    
                      return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
                  } else {
                      System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
                  }
                  return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
              }
          } finally {
              stringRedisTemplate.delete(REDIS_LOCK_KEY); //释放锁
          }
    
      }
  }
  

微服务机器宕机了

• 部署了微服务jar包的机器挂了，代码层面根本没有走到finally这块， 没办法保证解锁，这个key没有被删除，需要加入一个过期时间限定key

• 需要对lockKey有过期时间的设定

• 修改后版本

• @RestController
  public class GoodController {
    
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
          try {
              //setIfAbsent() 就是如果不存在就新建
              Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value); //setnx
              stringRedisTemplate.expire(REDIS_LOCK_KEY, 10 L, TimeUnit.SECONDS);
              if (!lockFlag) {
                  return "抢锁失败，┭┮﹏┭┮";
              } else {
                  String result = stringRedisTemplate.opsForValue().get("goods:001");
                  int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
                  if (goodsNumber > 0) {
                      int realNumber = goodsNumber - 1;
                      stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                      System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
    
                      return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
                  } else {
                      System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
                  }
                  return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
              }
    
          } finally {
              stringRedisTemplate.delete(REDIS_LOCK_KEY); //释放锁
          }
    
      }
  }
  

原子性操作

• 设置key+过期时间分开了，必须要合并成一行具备原子性

• 修改后版本

• @RestController
  public class GoodController {
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
          try {
              //setIfAbsent() == setnx 就是如果不存在就新建，同时加上过期时间保证原子性
              Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10 L, TimeUnit.SECONDS);
    
              if (!lockFlag) {
                  return "抢锁失败，┭┮﹏┭┮";
              } else {
                  String result = stringRedisTemplate.opsForValue().get("goods:001");
                  int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
                  if (goodsNumber > 0) {
                      int realNumber = goodsNumber - 1;
                      stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                      System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
    
                      return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
                  } else {
                      System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
                  }
                  return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
              }
          } finally {
              stringRedisTemplate.delete(REDIS_LOCK_KEY); //释放锁
          }
      }
  }
  

删除了别人的锁

• 张冠李戴，删除了别人的锁

• 

• 只能自己删除自己的，不许动别人的

• 修改后版本

• @RestController
  public class GoodController {
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
          try {
              //setIfAbsent() == setnx 就是如果不存在就新建，同时加上过期时间保证原子性
              Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10 L, TimeUnit.SECONDS);
                
              if (!lockFlag) {
                  return "抢锁失败，┭┮﹏┭┮";
              } else {
                  String result = stringRedisTemplate.opsForValue().get("goods:001");
                  int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
                  if (goodsNumber > 0) {
                      int realNumber = goodsNumber - 1;
                      stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                      System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
    
                      return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
                  } else {
                      System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
                  }
                  return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
              }
    
          } finally {
              if (value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(REDIS_LOCK_KEY))) {
                  stringRedisTemplate.delete(REDIS_LOCK_KEY); //释放锁
              }
          }
    
      }
  }
  

判断条件与删除动作的原子性

• finally块的判断+del删除操作不是原子性的

redis事务

• 用redis自身的事务

• 

• 修改后版本

• @RestController
  public class GoodController {
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
    
          try {
              //setIfAbsent() == setnx 就是如果不存在就新建，同时加上过期时间保证原子性
              Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10 L, TimeUnit.SECONDS);
                
              if (!lockFlag) {
                  return "抢锁失败，┭┮﹏┭┮";
              } else {
                  String result = stringRedisTemplate.opsForValue().get("goods:001");
                  int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
                  if (goodsNumber > 0) {
                      int realNumber = goodsNumber - 1;
                      stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                      System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
                      return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
                  } else {
                      System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
                  }
                  return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
              }
          } finally {
              while (true) {
                  stringRedisTemplate.watch(REDIS_LOCK_KEY); //加事务，乐观锁
                  if (value.equalsIgnoreCase(stringRedisTemplate.opsForValue().get(REDIS_LOCK_KEY))) {
                      stringRedisTemplate.setEnableTransactionSupport(true);
                      stringRedisTemplate.multi(); //开始事务
                      stringRedisTemplate.delete(REDIS_LOCK_KEY);
                      List list = stringRedisTemplate.exec();
                      if (list == null) { //如果等于null，就是没有删掉，删除失败，再回去while循环那再重新执行删除
                          continue;
                      }
                  }
                  //如果删除成功，释放监控器，并且breank跳出当前循环
                  stringRedisTemplate.unwatch();
                  break;
              }
          }
    
      }
  }
  

Lua脚本

• Redis可以通过eval命令保证代码执行的原子性

• 工具类

• public class RedisUtils {
    
      private static JedisPool jedisPool;
    
      static {
          JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
          jedisPoolConfig.setMaxTotal(20);
          jedisPoolConfig.setMaxIdle(10);
    
          jedisPool = new JedisPool(jedisPoolConfig, "ip", 6379, 100000);
      }
    
      public static Jedis getJedis() throws Exception {
          if (null != jedisPool) {
              return jedisPool.getResource();
          }
          throw new Exception("Jedispool is not ok");
      }
  }
  

• 修改后版本

• @RestController
  public class GoodController {
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() throws Exception {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
    
          try {
              //setIfAbsent() == setnx 就是如果不存在就新建，同时加上过期时间保证原子性
              Boolean lockFlag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK_KEY, value, 10 L, TimeUnit.SECONDS);
                
              if (!lockFlag) {
                  return "抢锁失败，┭┮﹏┭┮";
              } else {
                  String result = stringRedisTemplate.opsForValue().get("goods:001");
                  int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
                  if (goodsNumber > 0) {
                      int realNumber = goodsNumber - 1;
                      stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                      System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
                      return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
                  } else {
                      System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
                  }
                  return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
              }
          } finally {
              Jedis jedis = RedisUtils.getJedis();
    
              String script = "if redis.call('get', KEYS[1]) == ARGV[1]" + "then " +
                  "return redis.call('del', KEYS[1])" + "else " + "  return 0 " + "end";
              try {
                  Object result = jedis.eval(script, Collections.singletonList(REDIS_LOCK_KEY), Collections.singletonList(
                      value));
                  if ("1".equals(result.toString())) {
                      System.out.println("------del REDIS_LOCK_KEY success");
                  } else {
                      System.out.println("------del REDIS_LOCK_KEY error");
                  }
              } finally {
                  if (null != jedis) {
                      jedis.close();
                  }
              }
          }
    
      }
  }
  

分布式锁如何续期

• 确保redisLock过期时间大于业务执行时间的问题

• 集群+CAP对比zookeeper

• redis：AP，redis异步复制造成的锁丢失， 比如:主节点没来的及把刚刚set进来这条数据给从节点，就挂了。此时如果集群模式下，就得上Redisson来解决

• zookeeper：CP

• redis集群环境下，我们自己写的也不OK, 直接上RedLock之Redisson落地实现

• 配置类

  /**
   * 保证不是序列化后的乱码配置
   */
  @Configuration
  public class RedisConfig {
    
      @Value("${spring.redis.host}")
      private String redisHost;
    
      @Bean
      public RedisTemplate, Serializable > redisTemplate(LettuceConnectionFactory connectionFactory) {
          RedisTemplate,
          Serializable > redisTemplate = new RedisTemplate();
          redisTemplate.setKeySerializer(new StringRedisSerializer());
          redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
          redisTemplate.setConnectionFactory(connectionFactory);
          return redisTemplate;
      }
    
      @Bean
      public Redisson redisson() {
          Config config = new Config();
          config.useSingleServer().setAddress("redis://" + redisHost + ":6379").setDatabase(0);
          return (Redisson) Redisson.create(config);
      }
  }
  

• 修改后版本

• @RestController
  public class GoodController {
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @Autowired
      private Redisson redisson;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
    
          RLock redissonLock = redisson.getLock(REDIS_LOCK_KEY);
          redissonLock.lock();
          try {
              String result = stringRedisTemplate.opsForValue().get("goods:001");
              int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
              if (goodsNumber > 0) {
                  int realNumber = goodsNumber - 1;
                  stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                  System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
                  return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
              } else {
                  System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
              }
              return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
    
          } finally {
              redissonLock.unlock();
          }
      }
  }
  

• 可能会报错

• 

• 出现这个错误的原因：是在并发多的时候就可能会遇到这种错误，可能会被重新抢占

• 不见得当前这个锁的状态还是在锁定，并且本线程持有

• 修改后版本

• @RestController
  public class GoodController {
      public static final String REDIS_LOCK_KEY = "lockhhf";
    
      @Autowired
      private StringRedisTemplate stringRedisTemplate;
    
      @Value("${server.port}")
      private String serverPort;
    
      @Autowired
      private Redisson redisson;
    
      @GetMapping("/buy_goods")
      public String buy_Goods() {
    
          String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
    
          RLock redissonLock = redisson.getLock(REDIS_LOCK_KEY);
          redissonLock.lock();
          try {
              String result = stringRedisTemplate.opsForValue().get("goods:001");
              int goodsNumber = result == null ? 0 : Integer.parseInt(result);
    
              if (goodsNumber > 0) {
                  int realNumber = goodsNumber - 1;
                  stringRedisTemplate.opsForValue().set("goods:001", realNumber + "");
                  System.out.println("你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort);
                  return "你已经成功秒杀商品，此时还剩余：" + realNumber + "件" + "\t 服务器端口: " + serverPort;
              } else {
                  System.out.println("商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort);
              }
              return "商品已经售罄/活动结束/调用超时，欢迎下次光临" + "\t 服务器端口: " + serverPort;
    
          } finally {
              //还在持有锁的状态，并且是当前线程持有的锁再解锁
              if (redissonLock.isLocked() && redissonLock.isHeldByCurrentThread()) {
                  redissonLock.unlock();
              }
    
          }
      }
  }
  

总结

• synchronized 单机版oK，上分布式
• nginx分布式微服务 单机锁不行
• 取消单机锁 上redis分布式锁setnx
• 只加了锁，没有释放锁， 出异常的话，可能无法释放锁， 必须要在代码层面finally释放锁
• 宕机了，部署了微服务代码层面根本没有走到finally这块，没办法保证解锁，这个key没有被删除，需要有lockKey的过期时间设定
• 为redis的分布式锁key，增加过期时间此外，还必须要setnx+过期时间必须同一行的原子性操作
• 必须规定只能自己删除自己的锁，你不能把别人的锁删除了,防止张冠李戴，1删2,2删3
• lua或者事务
• redis集群环境下，我们自己写的也不OK直接上RedLock之Redisson落地实现

缓存过期淘汰策略

• 查看redis最大占用内存
• 配置文件
• 
• redis默认内存多少可以用？如果不设置最大内存大小或者设置最大内存大小为0，在64位操作系统中不限制内存大小；在32位操作系统下最大使用3GB内存
• 一般在生产上如何配置？一般推荐redis设置内存为最大物理内存的四分之三，也就是0.75
• 如何修改redis内存设置
• 配置文件
• 
• 命令
• 
• 什么命令查看redis内存使用情况？info memory
• 如果内存打满了会怎样？如果redis内存使用超出了设置的最大值会怎样？
• 

删除策略

• redis过期键的删除策略
  • 如果一个键是过期的，那它到了过期时间之后是不是马上就从内存中被被删除呢??
  • 如果不是，那过期后到底什么时候被删除呢?？是个什么操作?
• 三种不同的删除策略
  • 定时删除：Redis不可能时时刻刻遍历所有被设置了生存时间的key，来检测数据是否已经到达过期时间，然后对它进行删除。立即删除能保证内存中数据的最大新鲜度，因为它保证过期键值会在过期后马上被删除，其所占用的内存也会随之释放。但是立即删除对cpu是最不友好的。因为删除操作会占用cpu的时间，如果刚好碰上了cpu很忙的时候，比如正在做交集或排序等计算的时候，就会给cpu造成额外的压力，让CPU心累，时时需要删除，忙死；这会产生大量的性能消耗，同时也会影响数据的读取操作。总结：对CPU不友好，用处理器性能换取存储空间（拿时间换空间）
  • 惰性删除：数据到达过期时间，不做处理。等下次访问该数据时，如果未过期，返回数据；发现已过期，删除，返回不存在。惰性删除策略的缺点是，它对内存是最不友好的。如果一个键已经过期，而这个键又仍然保留在数据库中，那么只要这个过期键不被删除，它所占用的内存就不会释放。在使用惰性删除策略时，如果数据库中有非常多的过期键，而这些过期键又恰好没有被访问到的话，那么它们也许永远也不会被删除(除非用户手动执行FLUSHDB)，我们甚至可以将这种情况看作是一种内存泄漏–无用的垃圾数据占用了大量的内存，而服务器却不会自己去释放它们，这对于运行状态非常依赖于内存的Redis服务器来说,肯定不是一个好消息；总结：对memory不友好，用存储空间换取处理器性能（拿空间换时间)
  • 定期删除：定期删除策略是前两种策略的折中:定期删除策略每隔一段时间执行一次删除过期键操作，并通过限制删除操作执行的时长和频率来减少删除操作对CPU时间的影响。周期性轮询redis库中的时效性数据，采用随机抽取的策略，利用过期数据占比的方式控制删除频度；特点1：CPU性能占用设置有峰值，检测频度可自定义设置；特点2：内存压力不是很大，长期占用内存的冷数据会被持续清理；总结:周期性抽查存储空间（随机抽查，重点抽查)
  • 

淘汰策略

• 八种淘汰策略
  • noeviction: 不会驱逐任何key
  • allkeys-lru: 对所有key使用LRU算法进行删除（常用）
  • volatile-lru: 对所有设置了过期时间的key使用LRU算法进行删除
  • allkeys-random: 对所有key随机删除
  • volatile-random: 对所有设置了过期时间的key随机删除
  • volatile-ttl: 删除马上要过期的key
  • allkeys-lfu: 对所有key使用LFU算法进行删除
  • volatile-lfu: 对所有设置了过期时间的key使用LFU算法进行删除
• 如何配置，修改
• 
• 

LRU算法

• LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的数据予以淘汰。
• 算法来源
• 
• 设计思想
  • 所谓缓存，必须要有读+写两个操作，按照命中率的思路考虑，写操作+读操作时间复杂度都需要为O(1)
  • 必须有顺序之分，以区分最近使用的和很久没用到的数据排序。
  • 写和读操作 一次搞定。
  • 如果容量(坑位)满了要删除最不长用的数据，每次新访问还要把新的数据插入到队头(按照业务你自己设定左右那一边是队头)
  • 查找快，插入快，删除快，且还需要先后排序
• LRU的算法核心是哈希链表，本质就是HashMap+DoubleLinkedList 时间复杂度是O(1)，哈希表+双向链表的结合体

借助LinkedHashMap实现

public class LRUCacheDemo<K,V> extends LinkedHashMap<K, V> {

private int capacity;//缓存坑位

public LRUCacheDemo(int capacity) {
super(capacity,0.75F,false);
        this.capacity = capacity;
}

@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return super.size() > capacity;
}

public static void main(String[] args) {
        LRUCacheDemo lruCacheDemo = new LRUCacheDemo(3);

lruCacheDemo.put(1,"a");
lruCacheDemo.put(2,"b");
lruCacheDemo.put(3,"c");
System.out.println(lruCacheDemo.keySet());

lruCacheDemo.put(4,"d");
System.out.println(lruCacheDemo.keySet());

lruCacheDemo.put(3,"c");
System.out.println(lruCacheDemo.keySet());
lruCacheDemo.put(3,"c");
System.out.println(lruCacheDemo.keySet());
lruCacheDemo.put(3,"c");
System.out.println(lruCacheDemo.keySet());
lruCacheDemo.put(5,"x");
System.out.println(lruCacheDemo.keySet());
}
}

/**
 * true
 * [1, 2, 3]
 * [2, 3, 4]
 * [2, 4, 3]
 * [2, 4, 3]
 * [2, 4, 3]
 * [4, 3, 5]
 * */

/**
 [1, 2, 3]
 [2, 3, 4]
 [2, 3, 4]
 [2, 3, 4]
 [2, 3, 4]
 [3, 4, 5]
 */

自实现

public class LRUCacheDemo {


    //map负责查找，构建一个虚拟的双向链表，它里面安装的就是一个个Node节点，作为数据载体。

    //1.构造一个node节点作为数据载体
    class Node<K, V> {
        K key;
        V value;
        Node<K,V> prev;
        Node<K,V> next;

        public Node() {
            this.prev = this.next = null;
        }

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            this.prev = this.next = null;
        }

    }

    //2 构建一个虚拟的双向链表,,里面安放的就是我们的Node
    class DoubleLinkedList<K,V> {
        Node<K,V> head;
        Node<K,V> tail;

        public DoubleLinkedList() {
            head = new Node();
            tail = new Node();
            head.next = tail;
            tail.prev = head;
        }

        //3. 添加到头
        public void addHead(Node<K,V> node) {
            node.next = head.next;
            node.prev = head;
            head.next.prev = node;
            head.next = node;
        }

        //4.删除节点
        public void removeNode(Node<K, V > node) {
            node.next.prev = node.prev;
            node.prev.next = node.next;
            node.prev = null;
            node.next = null;
        }

        //5.获得最后一个节点
        public Node getLast() {
            return tail.prev;
        }
    }

    private int cacheSize;
    Map<Integer,Node<Integer, Integer >> map;
    DoubleLinkedList<Integer, Integer > doubleLinkedList;

    public LRUCacheDemo(int cacheSize) {
        this.cacheSize = cacheSize; //坑位
        map = new HashMap(); //查找
        doubleLinkedList = new DoubleLinkedList();
    }

    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }

        Node<Integer,Integer > node = map.get(key);
        doubleLinkedList.removeNode(node);
        doubleLinkedList.addHead(node);

        return node.value;
    }
    //saveOrUpdate method
    public void put(int key, int value) {
        if (map.containsKey(key)) { //update
            Node<Integer,Integer > node = map.get(key);
            node.value = value;
            map.put(key, node);

            doubleLinkedList.removeNode(node);
            doubleLinkedList.addHead(node);
        }
        else {
            if (map.size() == cacheSize) //坑位满了
            {
                Node<Integer,Integer > lastNode = doubleLinkedList.getLast();
                map.remove(lastNode.key);
                doubleLinkedList.removeNode(lastNode);
            }

            //新增一个
            Node<Integer,Integer > newNode = new Node(key, value);
            map.put(key, newNode);
            doubleLinkedList.addHead(newNode);

        }
    }

    public static void main(String[] args) {

        LRUCacheDemo lruCacheDemo = new LRUCacheDemo(3);

        lruCacheDemo.put(1, 1);
        lruCacheDemo.put(2, 2);
        lruCacheDemo.put(3, 3);
        System.out.println(lruCacheDemo.map.keySet());

        lruCacheDemo.put(4, 1);
        System.out.println(lruCacheDemo.map.keySet());

        lruCacheDemo.put(3, 1);
        System.out.println(lruCacheDemo.map.keySet());
        lruCacheDemo.put(3, 1);
        System.out.println(lruCacheDemo.map.keySet());
        lruCacheDemo.put(3, 1);
        System.out.println(lruCacheDemo.map.keySet());
        lruCacheDemo.put(5, 1);
        System.out.println(lruCacheDemo.map.keySet());

    }
}

/**
 * true
 * [1, 2, 3]
 * [2, 3, 4]
 * [2, 4, 3]
 * [2, 4, 3]
 * [2, 4, 3]
 * [4, 3, 5]
 * */

/**
 [1, 2, 3]
 [2, 3, 4]
 [2, 3, 4]
 [2, 3, 4]
 [2, 3, 4]
 [3, 4, 5]
 */