Redission使用

依赖：

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

配置类：

@Configuration
public class RedissionConfig {

    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }
}

1.redisson实现限流

    /**
     * redisson实现分布式限流
     */
    public void limitMethod() throws InterruptedException {
        //RateType.OVERALL,    //所有客户端加总限流，就是集群下所有的流量
        //RateType.PER_CLIENT; //每个客户端单独计算流量，每台机器的流量
        RRateLimiter myLimiter = redissonClient.getRateLimiter("myLimiter");
        //每秒钟产生2个令牌
        myLimiter.trySetRate(RateType.OVERALL, 2, 1, RateIntervalUnit.SECONDS);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        CountDownLatch latch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            final int x = i;
            executorService.submit(()->{
                System.out.println("请求接口:--->" + x);
                //acquire拿不到令牌则阻塞，等待产生令牌
                myLimiter.acquire();
                System.out.println("拿到锁：--->" + x);
                latch.countDown();
            });
        }
        latch.await();
        System.out.println("结束了。。。。。。。。");
    }

2.redisson实现延迟队列

    /**
     * redisson实现延迟队列
     */
    public void delayQueue() throws InterruptedException {
        RBlockingQueue<String> orderQueue = redissonClient.getBlockingQueue("orderQueue");
        RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue(orderQueue);
        CompletableFuture.runAsync(()->{
            while(true){
                String orderId = null;
                try {
                    orderId = orderQueue.take();
                    System.out.println("取消订单：" + orderId);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        for (int i = 0; i < 10; i++) {
            //10秒中后把消息发送到阻塞队列中
            delayedQueue.offer(i+"", 10 + i, TimeUnit.SECONDS);
            System.out.println("加入延迟订单取消队列：" + i);
        }

        Thread.sleep(10000000);
    }

3.redission实现分布式锁

    /**
     * redisson实现分布式锁
     * @throws InterruptedException
     */
    public void lockTest() throws InterruptedException {
        RLock lock = redissonClient.getLock("myLock");
        // lock()执行后，会加锁，默认设置过期时间30s，
        // 后台线程会在20s时判断锁是否释放，没有则进行续期，重新设置超时时间为30s,直到锁释放
        lock.lock();
        System.out.println("主线程，加锁成功.....");

        CompletableFuture.runAsync(()->{
            while(!lock.tryLock()){
                //System.out.println("没有获取到锁");
            }
            lock.lock();
            System.out.println("其他线程获取锁成功");
        });

        Thread.sleep(10000);
        System.out.println("主线程等待10秒，释放锁....");
        lock.unlock();
    }