redisson

redisson 使用

1，导入依赖

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

2，创建配置类

package com.woniu.config;

import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissConfig {

    @Bean
    public RedissonClient redisson(){
        //单机模式
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
        return  Redisson.create();
    }
}

3，代码实现

    @Autowired
    private RedissonClient redisson;

RLock lock = redisson.getLock("key");
try {
    //加锁
    //20: 若该线程第一次没有获取到锁，那么20秒内会 每隔 20/3 的时间尝试获取锁，直到20s过后才走到下一行代码
    //5:  锁的有效时间
    boolean result = lock.tryLock(20, 5, TimeUnit.SECONDS);
    //boolean result = lock.tryLock(); 若使用无参方法，若该线程第一次没有获取到锁，直接走到下一行代码，默认锁时间30s
    if(!result){
        System.out.println("没有抢到锁！");
        return;
    }
    //======业务代码==================
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    if(lock.isLocked() && lock.isHeldByCurrentThread()){
                lock.unlock();//释放锁
    }
}

课上代码

    /**
     * 用redisson实现分布式锁
     * 步骤：
     * 1、去尝试放锁
     *
     * @param id
     * @return
     */
public ResponseData<?> startKill(Integer id) {
    RLock lock = redisson.getLock("lock");
    try {
        boolean b = lock.tryLock();//当前线程能不能获取锁
        //tryLock()：锁默认时间30秒，每过30秒/3，会检测主线程有没有执行完，如果没有执行完，会给主线程执行时间续30秒（watch dog）
        if (b) {
            KillBook killBook = (KillBook) redisTemplate.opsForHash().get("killBook", String.valueOf(id));
            if (killBook != null && killBook.getKillNum() > 0) {
                killBook.setKillNum(killBook.getKillNum() - 1);
                System.out.println("商品库存" + killBook.getKillNum());
                redisTemplate.opsForHash().put("killBook", String.valueOf(id), killBook);
                return new ResponseData<>().ok(null);
            } else {
                return new ResponseData<>().fail();
            }
        } else {
            return new ResponseData<>().fail();
        }
    } finally {
        //判断有没有加上锁，和判断此锁是不是当前线线程锁持有的（只有加上锁，才能释放锁）
        if(lock.isLocked() && lock.isHeldByCurrentThread()){
            lock.unlock();//释放锁
        }

    }
}

中间函数 可以有很多次：filter map sorted limit distinct

终端操作 一次：forEach count max

g-exrbTBVf-1691409467848)]

中间函数 可以有很多次：filter map sorted limit distinct

终端操作 一次：forEach count max


面试题
分布锁，本地锁
1：为什么要用分布式锁？
在集群部署，分布式，本地锁是没有（锁不住非原子性代码）
只能用分布锁实现

2：实现分布锁有哪几种技术
比较流行的实现分布锁的技术有三种
第一种：利用数据库主键唯一特点实现
第二种：利用redis 一个命令setnx,(setnx:尝试让Redis种放一个（key-val）,
如果能放进去，返回ture,反之返回false)
第三种：利用zeekpeer(节点)

3：怎么实现分布锁，
用redis 怎么实现分布锁。
步骤
1.调用setifsend() 其实就是封装setnx命令
2:业务代码只有拿到锁的线程才能只能（应为要保证非原子性操作的代码，同时有一个线程执行）
3：删除锁
理由redis的setnx 实现有两个问题
1：锁的时间不好指定
2：删除锁不是原子性的操作，高并发会有问题（reids lua脚本去删除）

用reisson实现分布式

利用redis实现分布式锁实现解决书籍超卖的问题

/**
     * 利用redis实现分布式锁实现解决书籍超卖的问题
     * 步骤：
     * 1、调用setIfAbsent去尝试往redis中放一个key-val(),能放进去返回true，放不进去返回false
     * 2、通过返回判断，返回true才能执行业务代码
     * 3、删除锁
     *
     * @param id
     * @return
     */
//    @Override
    public ResponseData<?> startKillA(Integer id) {
        long id1 = Thread.currentThread().getId();
        Boolean redislock = redisTemplate.opsForValue().setIfAbsent("lock", id1, 10, TimeUnit.SECONDS);
        KillBook killBook = (KillBook) redisTemplate.opsForHash().get("killBook", String.valueOf(id));
        try {
            if (redislock) {

                if (killBook != null && killBook.getKillNum() > 0) {
                    killBook.setKillNum(killBook.getKillNum() - 1);
                    System.out.println("商品库存" + killBook.getKillNum());
                    redisTemplate.opsForHash().put("killBook", String.valueOf(id), killBook);
                    return new ResponseData<>().ok(null);
                } else {
                    return new ResponseData<>().fail();
                }
            } else {
                //没有拿到锁，直接返回，不执行业务代码
                return new ResponseData<>().fail();
            }
        } finally {
            if (redisTemplate.opsForValue().get("lock") != null) {
                //删除锁
                if (id1 == (int) redisTemplate.opsForValue().get("lock")) {
                    redisTemplate.delete("lock");
                }
            }
        }
    }