Redisson分布式锁

1.第一步导入redisson依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.0</version>
</dependency>

2.创建一个redisson的配置类RedissonConfig，内容如下：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import java.io.IOException;
 
@Configuration
public class RedissonConfig {
 
    @Value("${spring.redis.host}")
    private String host;
 
    @Value("${spring.redis.port}")
    private String port;
 
    @Value("${spring.redis.password}")
    private String password;
 
    /**
     * RedissonClient,单机模式
     * @return
     * @throws IOException
     */
    @Bean()
    public RedissonClient redisson()  {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        return Redisson.create(config);
    }
}

3.Redisson分布式锁 --- lock()锁  

可以有效解决秒杀超买超卖的问题

@Resource
private Redisson redisson;
 
 
 @Override
    public String getmiaosha() {
        //创建分布式锁对象
        RLock lock = redisson.getLock("miaosha");
        
        try {
            //加锁
            lock.lock();
            MiaoShaEntity miaoShaEntity = miaoShaMapper.selectById(1);
            if (miaoShaEntity.getNumber() < 1){
                System.out.println("库存不足");
                return "库存不足";
            }
            Integer number = miaoShaEntity.getNumber()-1;
            miaoShaEntity.setNumber(number);
            miaoShaMapper.updateById(miaoShaEntity);
            System.out.println("库存扣减成功！剩余库存" + number);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //解锁
            lock.unlock();
        }
        return "success";
    }
}

4.Redisson分布式锁 --- 读写锁

一般用于读的时候不能写 ，写的时候不能读 这种场景

/**
     * 加写锁
     * 保证一定能读到最新的数据
     * @return {@link String}
     */
    @Override
    public String getWritemiaosha() {
        //创建锁对象
        RReadWriteLock readWritelock = redisson.getReadWriteLock("ReadWritelock");
        //创建写锁对象
        RLock rLock = readWritelock.writeLock();
        try {
            //加写锁
            rLock.lock();

            /*
             * 这里写业务逻辑
             * */

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            rLock.unlock();
        }
        return "success";
    }


    /**
     * 加读锁
     * 
     * @return {@link String}
     */
    @Override
    public String getRedemiaosha() {
        //创建锁对象
        RReadWriteLock readWritelock = redisson.getReadWriteLock("ReadWritelock");
        //创建读锁对象
        RLock rLock = readWritelock.readLock();
        try {
            //加读锁
            rLock.lock();

            /*
             * 这里写业务逻辑
             * */

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            rLock.unlock();
        }
        return "success";
    }

5.Redisson分布式锁 --- 信号量锁

信号量也可以用作分布式限流

//试用场景一//
    
    /**
     * 车库停车
     * 3个车位
     *
     * @return {@link String}
     */
    @Override
    public String park() throws InterruptedException {
        //创建锁对象
        RSemaphore park = redisson.getSemaphore("park");
        //获取一个信号，获取一个值，占一个车位
        park.acquire();
        return "ok";
    }
    
    @Override
    public String go() throws InterruptedException {
        //创建锁对象
        RSemaphore park = redisson.getSemaphore("park");
        //释放一个车位
        park.release();
        return "ok";
    }
}


   //试用场景二//
   
     /**
     * 车库停车
     * 3个车位
     * 信号量也可以用作分布式限流
     *
     * @return {@link String}
     */
    @Override
    public String park() throws InterruptedException {
        //创建锁对象
        RSemaphore park = redisson.getSemaphore("park");
        //获取一个信号，获取一个值，占一个车位
        boolean b = park.tryAcquire();
        if (b){
            //执行业务
        }else {
            return "error";
        }
        return "ok";
    }

    @Override
    public String go() throws InterruptedException {
        //创建锁对象
        RSemaphore park = redisson.getSemaphore("park");
        //释放一个车位
        park.release();
        return "ok";
    }

5.Redisson分布式锁 --- 闭锁

    /**
     * 放假，锁门
     * 1班人没了，2
     * 5个班全部走完了，我们才可以锁大门
     * @return {@link String}
     */
    @GetMapping("/lockDoor")
    @ResponseBody
    public String lockDoor() throws InterruptedException {
        //创建锁对象
        RCountDownLatch door = redisson.getCountDownLatch("door");
        door.trySetCount(5);
        door.await();//等待闭锁都完成
        return "放假了。。。";
    }

    @GetMapping("/gogogo/{id}")
    @ResponseBody
    public String gogogo(@PathVariable("id") Long id) throws InterruptedException {
        //创建锁对象
        RCountDownLatch door = redisson.getCountDownLatch("door");
        door.countDown();//计数减一
        return id+"班都人都走了。。。";
    }