高并发的优化方案（延迟队列的使用）

1.高并发优化方案

解决高并发问题从宏观角度来说有3个方向：

其中，水平扩展和服务保护侧重的是运维层面的处理。而提高单机并发能力侧重的则是业务层面的处理，也就是我们程序员在开发时可以做到的。

1.1.单机并发能力

在机器性能一定的情况下，提高单机并发能力就是要尽可能缩短业务的响应时间（ResponseTime），而对响应时间影响最大的往往是对数据库的操作。而从数据库角度来说，我们的业务无非就是读或写两种类型。
对于读多写少的业务，其优化手段主要包括两方面：

• 优化代码和SQL
• 添加缓存

对于写多读少的业务，较少碰到，因此介绍此方面的优化方案。

对于高并发写的优化方案有：

• 优化代码及SQL
• 变同步写为异步写
• 合并写请求

1.2.变同步为异步

假如一个业务比较复杂，需要有多次数据库的写业务，如图所示：

由于各个业务之间是同步串行执行，因此整个业务的响应时间就是每一次数据库写业务的响应时间之和，并发能力肯定不会太好。
优化的思路很简单，利用MQ可以把同步业务变成异步，从而提高效率。

• 当我们接收到用户请求后，可以先不处理业务，而是发送MQ消息并返回给用户结果。
• 而后通过消息监听器监听MQ消息，处理后续业务。
  
  优点：
• 无需等待复杂业务处理，大大减少响应时间
• 利用MQ暂存消息，起到流量削峰整形作用
• 降低写数据库频率，减轻数据库并发压力
  缺点：
• 依赖于MQ的可靠性
• 降低了些频率，但是没有减少数据库写次数
  应用场景：
• 比较适合应用于业务复杂， 业务链较长，有多次数据库写操作的业务。

1.3.合并写请求

合并写请求方案其实是参考高并发读的优化思路：当读数据库并发较高时，我们可以把数据缓存到Redis，这样就无需访问数据库，大大减少数据库压力，减少响应时间。

合并写请求就是指当写数据库并发较高时，不再直接写到数据库。而是先将数据缓存到Redis，然后定期将缓存中的数据批量写入数据库。

由于Redis是内存操作，写的效率也非常高，这样每次请求的处理速度大大提高，响应时间大大缩短，并发能力肯定有很大的提升。

优点：

• 写缓存速度快，响应时间大大减少
• 降低数据库的写频率和写次数，大大减轻数据库压力
  缺点：
• 实现相对复杂
• 依赖Redis可靠性
• 不支持事务和复杂业务
  场景：
• 写频率较高、写业务相对简单的场景

2. 延迟任务方案

延迟任务的实现方案有很多，常见的有四类：

	DelayQueue	Redisson	MQ	时间轮
原理	JDK自带延迟队列，基于阻塞队列实现。	基于Redis数据结构模拟JDK的DelayQueue实现	利用MQ的特性。例如RabbitMQ的死信队列	时间轮算法
优点	不依赖第三方服务	分布式系统下可用 不占用JVM内存	分布式系统下可以 不占用JVM内存	不依赖第三方服务 性能优异
缺点	占用JVM内存	只能单机使用	依赖第三方服务	依赖第三方服务

2.1 DelayQueue的原理

DelayQueue的源码：

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
    implements BlockingQueue<E> {

    private final transient ReentrantLock lock = new ReentrantLock();
    private final PriorityQueue<E> q = new PriorityQueue<E>();
    
    // ... 略
}

可以看到DelayQueue实现了BlockingQueue接口，是一个阻塞队列。队列就是容器，用来存储东西的。DelayQueue叫做延迟队列，其中存储的就是延迟执行的任务。
DelayQueue的泛型定义：

DelayQueue<E extends Delayed>

这说明存入DelayQueue内部的元素必须是Delayed类型，这其实就是一个延迟任务的规范接口。来看一下：

public interface Delayed extends Comparable<Delayed> {

    /**
     * Returns the remaining delay associated with this object, in the
     * given time unit.
     *
     * @param unit the time unit
     * @return the remaining delay; zero or negative values indicate
     * that the delay has already elapsed
     */
    long getDelay(TimeUnit unit);
}

从源码中可以看出，Delayed类型必须具备两个方法：

• getDelay()：获取延迟任务的剩余延迟时间
• compareTo(T t)：比较两个延迟任务的延迟时间，判断执行顺序

可见，Delayed类型的延迟任务具备两个功能：获取剩余延迟时间、比较执行顺序。当然，我们可以对Delayed做实现和功能扩展，比如添加延迟任务的数据。

2.2 DelayQueue的用法

首先定义一个Delayed类型的延迟任务类，要能保持任务数据。

package com.tianji.learning.utils;

import lombok.Data;

import java.time.Duration;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

@Data
public class DelayTask<D> implements Delayed {
    private D data;
    private long deadlineNanos;

    public DelayTask(D data, Duration delayTime) {
        this.data = data;
        this.deadlineNanos = System.nanoTime() + delayTime.toNanos();
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(Math.max(0, deadlineNanos - System.nanoTime()), TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        long l = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        if(l > 0){
            return 1;
        }else if(l < 0){
            return -1;
        }else {
            return 0;
        }
    }
}

接下来就可以创建延迟任务，交给延迟队列保存：

package com.tianji.learning.utils;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.time.Duration;
import java.util.concurrent.DelayQueue;

@Slf4j
class DelayTaskTest {
    @Test
    void testDelayQueue() throws InterruptedException {
        // 1.初始化延迟队列
        DelayQueue<DelayTask<String>> queue = new DelayQueue<>();
        // 2.向队列中添加延迟执行的任务
        log.info("开始初始化延迟任务。。。。");
        queue.add(new DelayTask<>("延迟任务3", Duration.ofSeconds(3)));
        queue.add(new DelayTask<>("延迟任务1", Duration.ofSeconds(1)));
        queue.add(new DelayTask<>("延迟任务2", Duration.ofSeconds(2)));
        // TODO 3.尝试执行任务
        
    }
}

最后，补上执行任务的代码：

package com.tianji.learning.utils;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.time.Duration;
import java.util.concurrent.DelayQueue;

@Slf4j
class DelayTaskTest {
    @Test
    void testDelayQueue() throws InterruptedException {
        // 1.初始化延迟队列
        DelayQueue<DelayTask<String>> queue = new DelayQueue<>();
        // 2.向队列中添加延迟执行的任务
        log.info("开始初始化延迟任务。。。。");
        queue.add(new DelayTask<>("延迟任务3", Duration.ofSeconds(3)));
        queue.add(new DelayTask<>("延迟任务1", Duration.ofSeconds(1)));
        queue.add(new DelayTask<>("延迟任务2", Duration.ofSeconds(2)));
        // 3.尝试执行任务
        while (true) {
            DelayTask<String> task = queue.take();
            log.info("开始执行延迟任务：{}", task.getData());
        }
    }
}

注意：
这里我们是直接同一个线程来执行任务了。当没有任务的时候线程会被阻塞。而在实际开发中，我们会准备线程池，开启多个线程来执行队列中的任务。