关于DeferredResult的思考

使用SpringBoot搭建web程序，里面内置了tomcat，一般都不会关心内部实现机制，上来就可以写程序，并且可以跑起来。但是是思考了每次的请求是如何工作的。

简单的来讲就是tomcat是将每次请求都将封装成一个Servlet,该Servlet来运行完业务逻辑代码，然后再有tomcat将信息返回给调用方。每个Servlet是同步的。即在该servlet的业务逻辑做完了然后才释放掉该Servlet。

但是servlet3提供了一个异步的机制，即每次请求过来之后，可以先释放该请求，但是会保存一些信息。业务逻辑由程序其他线程来处理，处理完成后将其值设置到DeferredResult里面。然后再由容器将返回值返回给前端。

这样做的好处：实现出现请求与业务IO分开，程序能够处理更多的请求。

网上可以找到其他例子来学习DeferredResult是如何运行的，即在请求内部开启一个线程来处理

@GetMapping
public DeferredResult<String> queryDevice(){
	DeferredResult<String> def = new DeferredResult<>();
	new Thread(()->{
		//处理业务逻辑
		def.setResult("处理后的结果");
	}).start();
	return def;
}

这样很好理解，但是不能这样做，为什么，因为每一次线程的创建销毁是消耗资源的，这样频繁的创建和销毁非常影响性能。这个时候，可以提使用线程池来处理，对是可以这样做的。是的，可以这样做，但是需要考虑到，在某一时刻，可能会产生几千个线程，这样是非常多的，如果加上tomcat创建的Servlet线程数，那确实挺消耗资源的。

上面已经有了一个可行的方案，这里提供我的一个思考，该思考是Java8新特性之后常用到的一个。

下面有三个类：

public abstract class Actor {

  public enum ActorType {
    ITC,  /* 立刻消费. */

    BLOCKING;  /* 阻塞.*/
  }
  /**
   * actor类型.
   */
  public ActorType type;
  /**
   * actor名.
   */
  public String name;
  public Actor(ActorType type) {
    this.type = type;
    this.name = this.getClass().getSimpleName();
  }
  /**
   * 任务消费
   */
  public void future(Consumer<Void> c) {
    if (this.type.ordinal() == ActorType.BLOCKING.ordinal()) {//阻塞
      ((ActorBlocking) this).push(c);
      return;
    } else {
      Misc.exeConsumer(c, null);
    }
  }
}

public class ActorBlocking extends Actor {

  /**
   * 等待处理的Consumer.
   */
  private ConcurrentLinkedQueue<Consumer<Void>> cs = new ConcurrentLinkedQueue<>();
  /**
   * 拥有线程的个数
   */
  private int tc = 1;

  /**
   * cs的size
   */
  private AtomicInteger size = new AtomicInteger(0);

  /**
   * 线程忙？
   */
  public volatile boolean busy = false;

  public ActorBlocking() {
    super(ActorType.BLOCKING);
  }

  /**
   * 添加任务.
   */
  public void push(Consumer<Void> c) {
    this.cs.add(c);
    this.size.incrementAndGet();
    synchronized (this) {//通知线程消费信息
      this.notify();
    }
  }

  /**
   * 线程忙?
   */
  public boolean isBusy() {
    return this.busy;
  }

  /**
   * 队列尺寸.
   */
  public int size() {
    return this.size.get();
  }

  public int getTc() {
    return tc;
  }

  public void setTc(int tc) {
    this.tc = tc < 1 ? 1 : tc;
  }

  /**
   * 启动线程
   */
  protected void start() {
    ActorBlocking ab = this;
    ExecutorService ex = Executors.newFixedThreadPool(this.tc);//创建线程池
    for (int i = 0; i < tc; i++) {
      ex.execute(() -> {
        while (true) {
          ab.run();
        }
      });
    }
  }

  /**
   * 抢占式消费任务
   */
  private void run() {
    Consumer<Void> c = this.cs.poll();
    if (c == null) {
      synchronized (this) {
        try {
          this.wait();
        } catch (InterruptedException e) {
        }
      }
      c = this.cs.poll();
    }
    if (c != null) /* 抢占式. */ {
      this.size.decrementAndGet();
      this.busy = true;
      Misc.exeConsumer(c, null);
      this.busy = false;
    }
  }
}

@Component
public class AppActorBlocking extends ActorBlocking {
   //可以设置CPU*2的
  private int threadSize = 4;

  public AppActorBlocking() {
    this.setTc(threadSize);//设置线程数量
    this.start();
  }
}

该方法是工具Misc类总的方法：

 /**
   * 执行Consumer并将异常化解在内部.
   */
  public static final <T> boolean exeConsumer(Consumer<T> c, T t) {
    try {
      c.accept(t);
      return true;
    } catch (Exception e) {
      if (logger.isWarnEnabled()) {
        logger.warn("{}", Misc.trace(new Throwable()));
      }
      if (logger.isWarnEnabled()) {
        logger.warn("t: {}, e: {}", t, Misc.trace(e));
      }
      return false;
    }
  }

如何调用：

@Autowired
public AppActorBlocking appBlocking;

public void method(){
	appBlocking.future(v->{
		//处理逻辑代码
	});
}

上面的代码理解是所有的业务逻辑都是一个个Task,每一次请求过来，那么我就将业务逻辑代码生成一个Task，放入到队列中，然后由线程去取其中的任务来消费。

这里仅仅是换了一个思路，不是由线程池去创建线程来处理，而是创建几个线程，然后抢占式的去消费任务，而过来的每次请求，都会放入到队列中。

DeferredResult的异步处理能够提升一些服务器的性能，处理更多的连接数，但是一个WEB程序，处理连接数还与内置默认的tomcat相关（SpringBoot下还有其他容器），即tomcat默认的处理最大连接数为200,除了最大连接数，还有一个tomcat的最大处理线程数，如果该处设置小了，那么并发也一定会小，在设置这些之外，需要设置一个等待队列的大小，总有一些请求是不能被处理的，但又不能拒绝掉，否则用户体验特别不好，那么就进入到等待队列中，等tomcat有空闲的线程再来处理等待队列中的线程。

至于什么时候用到该DeferredResult，如果是访问量不大的程序，如管理系统，没必要使用到这个，毕竟没有访问量，反而增大了开发量，但是如果做了很好的封装，那么就没关系了，这个就考量各自程序员的水平了。