redis分布式锁(生产环境可用,支持多种高并发)

package com.redis.lock;

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
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.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

* 锁的三种问题:
* 分布式锁的问题:
*   1.程序本身出现问题
*   2.运维的发布或者机器宕机,
*   导致锁一直存在;锁没有释放
*   为什么是用redis作为分布式锁?或者redis可以跨ip
*     根本原因就是:不同的物理机配置的是同一个redis实例,否则如果配置不同的redis实例,那么就不存在redis作为分布式锁的实例
* 1.死锁问题:
*       解决方案: 超时时间解决      达到时间,锁自动失效,否则就需要手动的去解决,这个超时时间很难评估,一般不要太长
*                 try--finally解决. 删除key;
* 2.锁互换问题:
*         锁的失效时间与程序的执行时间不一样
*         1.锁的失效时间短
*         2.程序的执行时间长.
*         当程序的执行时间大于锁的失效时间时,当前的线程程序没有执行完毕,但是锁已经释放,导致其他的线程重新获取锁,并且
*         当前线程释放的锁不是自己本身的锁,从而出现锁互换的问题;
*         核心:自己加的锁,被别的线程释放掉了.相当于自己没有加锁
*         解决方案:
*            给每一个线程或者每一个用户设置一个自己的唯一值,也就是给每一个key设置一个自己专属的value值.比如uuid;
*            进行相同值的判断.保证原子性操作.
*
* 3.锁续命问题:
*          这个超时时间很难评估,一般不要太长,那么怎么解决呢?
*            Redisson解决

/**
 * 不同的jvm或者夸jvm,实质上是指夸的是不同的物理机ip,那么redis为什么能在不同的jvm,不同的物理机上运行,并且对不同的物理机
 * 都是可见的,其实质就是redis的共享性,将竞争资源放在redis上,解决并发问题
 * <p>
 * 2.分布式锁的三种问题:
 * 1.系统抛异常   try---finally--
 * 2.系统宕机     锁失效时间,自动失效时间
 * 3.锁互换      超时时间<业务执行时间,导致锁互换,被其他的线程释放掉,通过加值判断
 * 4.锁续命
 * 5.如果redis的内存满了,则采用淘汰策略,默认使用的是IRU
 */
@RestController
public class InndexController {

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

    //解决redis缓存穿透的问题-布隆过滤器
    BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.forName("utf-8")), 1000, 0.01);
    //
//    @Autowired
//    private Redisson redisson;
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * sysnchronized关键字怎么知道是同一个对象获取的锁?
     * 原子操作没法执行,最完美的就是原子操作;
     * redisson用了大量的原子操作,
     * 主存锁失效的解决方案: 1.zookeeper 强一致性
     * 2.redLock
     * 代码的线性执行...锁的原理;
     * 高并发分布式锁的实现:
     * 抢购同一个商品.
     * 分段锁:
     * 抢购不同的商品,可以加机器,redis-cluster的集群;
     *
     * @return
     */
    @PostConstruct
    public void init() {
        Set<String> keys = redisTemplate.keys("*");  //获取所有的key
        HashMap<String, Object> map = new HashMap<>();
        for (String onlKey : keys) {
            String s = redisTemplate.opsForValue().get(onlKey);
            map.put(onlKey, s);
        }
        //将所有的key放入到bloom过滤器中
        for (String key : keys) {
            bloomFilter.put("product_0001");
        }
    }

    @GetMapping("/deduct_stock")
    public String deductStock() {
        String lockKey = "product_0001";
        String clientID = UUID.randomUUID().toString();
//        RLock redissonLock = redisson.getLock(lockKey);
        try {
            boolean contain = bloomFilter.mightContain(lockKey);
            if (!contain) {
                return "";
            }
            //获取锁
//            Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, "zhuge"); //1
//            如果在1和2之间出问题呢?用下面的综合解决
            Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, clientID, 10, TimeUnit.SECONDS);
//            2.系统宕机,加超时时间
//            redisTemplate.expire(lockKey, 10, TimeUnit.SECONDS);//2
//              3.锁互换问题-->锁失效的时间<系统业务执行的时间,发生锁互换的问题;
            if (!result) {   //如果返回false,那么redis中已经存在这个key
                return "error";
            }
            //缓存穿透的判断.
            //逻辑理解清楚,剩下的就是代码编写的顺序问题,也就是让程序不要运行的太深然后出现问题,让问题提前出现
            //判断key是否存在,如果不存在则直接返回
            //加锁实现锁续命功能
//            redissonLock.lock();
            //jdk的各种锁都是基于jvm存在的,如果是夸jvm或者分布式微服务架构,那么用redis的共享特性,夸jvm存在的共享资源
            String stock = redisTemplate.opsForValue().get("stock");//key是业务的唯一标示
            int parseInt = Integer.parseInt(stock);
            if (parseInt > 0) {
                int realStock = parseInt - 1;
                redisTemplate.opsForValue().set("stock", realStock + ""); //值是业务的值;\
                System.out.println("剩余的库存值为: " + realStock);
            } else {
                System.out.println("扣减失败,库存不足");
            }
        } finally {
//            redissonLock.unlock();
            String s = redisTemplate.opsForValue().get(lockKey);
            System.out.println("当前key对应的值为: " + s);
            if (clientID.equals(s)) {
                System.out.println("删除锁成功");
                redisTemplate.delete(lockKey);
            } else {
                System.out.println("删除锁失败");
            }
        }
        //假如中间的代码出问题了,抛异常了,那么锁释放不了,怎么办?try...finally,要不然就死锁了
        /**
         * 1.抛异常,导致死锁,用try..finally..去解决
         *
         */
        //释放锁

        return "end";
    }
}