Redis锁的不同形式与分类（redis锁的种类）

Redis锁是Redis的一种功能，它可以在不同的进程和服务之间互斥访问共享资源，以避免资源竞争，因此被广泛的应用在各种场景中，比如控制访问频率、防止缓存雪崩等。Redis锁有很多种不同的形式，分为4种类型：期限锁、可重入锁、计数锁、分布式锁。

1. 期限锁：期限锁是一种让工作程序拥有指定的租用期限的锁，租用时间超过期限后，就会被自动释放，避免了死锁问题导致工作程序卡死的情况。这种锁可以有效的防止一个长时间执行的任务耗费过多的系统资源。

例子：

 String lockKey = "example_key";
 long lockExpire = 18000;//单位：s

 String lockValue = String.valueOf(System.nanoTime());
 if(redisTemplate.opsForValue().setIfAbsent(lockKey,lockValue)){
      redisTemplate.expire(lockKey, lockExpire, TimeUnit.SECONDS);
      //doSomething
      //释放锁
      String currentlockValue = redisTemplate.opsForValue().get(lockKey).toString();
      if(currentlockValue == lockValue){
           redisTemplate.delete(lockKey);
      }
 }

2. 可重入锁：可重入锁又称为递归锁或可递归锁，具有非常实用的可重入性，获取锁定的线程可以在释放锁之前多次获取该线程，是一种常用的锁定策略。

例子：

 private ThreadLocal> threadLocalMap = new ThreadLocal>();

    public void lock(String key){
        获取锁信息
        String lock = redisTemplate.opsForValue().get(key);
        //判断获取的锁是否等于当前的线程
        if(lock.equals(Thread.currentThread().toString())){
            Map threadMap= threadLocalMap.get();
            //若是空值
            if(threadMap==null){
                threadMap=new HashMap();
                threadMap.put(key,1);
            } else { 
                int lockCount= threadMap.get(key);
                threadMap.put(key,++lockCount);
            }
            return;
        }

        //若不是
        try {
            do {
                Thread.sleep(10);
            } while (!redisTemplate.opsForValue().setIfAbsent(key, Thread.currentThread().toString()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void unlock(String key){
        Map threadMap= threadLocalMap.get();
        if(threadMap==null){
            return;
        }
        int lockCount= threadMap.get(key);
        if(lockCount==1){
            redisTemplate.delete(key);
        } else {
            threadMap.put(key,--lockCount);
        }
    }

3. 计数锁：计数锁是Redis的一种典型的分布式锁，通过Redis的原子操作实现，可以防止其他进程抢占锁失败回滚的情况发生。当多个进程拿同一个锁时，计数锁可以用来区分各个进程的获取次数，以便更好的实现一致性的操作。

例子：

    private ThreadLocal> threadLocalMap = new ThreadLocal>();

    public void lock(String key) {
        lock = redisTemplate.opsForValue().get(key);

        // 获取锁计数
        int lockCount = getLockCount(lock);

        if (lockCount > 0) {
            // 锁数量大于最大可用数量
            return;
        }

        // 锁数量小于最大可用数量，设置锁并记录本地线程计数
        if (redisTemplate.opsForValue().setIfAbsent(key, threadLocalMap.get().toString())) {
            Map threadMap = threadLocalMap.get();
            if (threadMap == null) {
                threadMap = new HashMap();
                threadMap.put(key, 1);
            } else {
                int threadCount = threadMap.get(key);
                threadMap.put(key, ++threadCount);
            }
            return;
        }
    }

    public void unlock(String key) {
        Map threadMap = threadLocalMap.get();
        if (threadMap == null) {
            return;
        }
        int lockCount= threadMap.get(key);
        if(lockCount==1){
            redisTemplate.delete(key);
        } else {
            threadMap.put(key,--lockCount);
        }
    }