最近接触到响应式编程的概念，简单了解了一下在java中的响应式编程。响应式编程是一个专注于数据流和变化传递的异步编程范式。
响应式编程是一种编程概念，在很多编程语言中都有应用。其中，在Java中，我们比较熟悉的有RxJava，有关RxJava的介绍，已经有大神写出比较完善的介绍：
深入浅出RxJava（一：基础篇）
深入浅出RxJava(二：操作符)
深入浅出RxJava三–响应式的好处
以上三篇博客已经初步介绍RxJava的使用方式以及一些应用场景，在此不再多介绍如何使用，这里尝试简单分析一下他的设计原理以及实现方式。
响应式编程是观察者模式的扩展，RxJava中的实现也是如此。下面是一个观察者模式demo。
public class ReactiveDemo {
public static void main(String[] args){
//可观察对象
MyObservable observable = new MyObservable();
//添加观察者
observable.addObserver((o, arg) -> {
Util.println("观察者1处理事件:" + arg.toString());
});
observable.addObserver((o, arg) -> {
Util.println("观察者2处理事件:" + arg.toString());
});
observable.addObserver((o, arg) -> {
Util.println("观察者3处理事件:" + arg.toString());
});
//发布事件通知观察者
observable.setChanged();
observable.notifyObservers("事件@@");
}
static class MyObservable extends Observable{
@Override
public void setChanged(){
super.setChanged();
}
}
}
执行输出
2018-06-23 18:16:43:993[main] 观察者3处理事件:事件@@
2018-06-23 18:16:44:015[main] 观察者2处理事件:事件@@
2018-06-23 18:16:44:015[main] 观察者1处理事件:事件@@从输出可以看出，代码的执行顺序并非按照我们的代码顺序执行，而是反过来，通过debug可以进一步看到，在添加观察者回调函数时，回调函数代码没有执行（这不是废话嘛0.0），知道被观察者发布事件通知观察者处理事件时才执行回调函数，并且都是在main线程中同步执行。这种方式可以称为同步非阻塞的响应式编程。既然有同步式的非阻塞，那就有异步非阻塞的响应式编程，在Java中的Swing就是一个很好的例子。
下面看一下我们最常见的一个swing例子。
public class SwingFrame {
public static void main(String[] args) {
JFrame jFrame = new JFrame();
jFrame.setVisible(true);
jFrame.setBounds(200,200,400,400);
jFrame.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
super.mouseClicked(e);
CommonUtil.println("鼠标点击事件");
}
});
jFrame.addFocusListener(new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
super.focusGained(e);
CommonUtil.println("焦点事件");
}
});
}
}
执行程序，看看鼠标点击事件和焦点事件。
2018-06-24 07:53:20:753[AWT-EventQueue-0] 焦点事件
2018-06-24 07:53:25:216[AWT-EventQueue-0] 鼠标点击事件
2018-06-24 07:53:27:849[AWT-EventQueue-0] 焦点事件
2018-06-24 07:53:30:416[AWT-EventQueue-0] 鼠标点击事件
尝试了几次，发现在swing的事件响应处理并不是在main线程里面进行处理的，鼠标点击和焦点事件处理都是在一个叫AWT-EventQueue-0的线程中进行处理，可以看见这种异步处理的方式有别于上面的观察者模式。这里对于事件的响应更加类似于一种对事件进行拉取的方式，我们点击窗体，发现打印鼠标事件是有延迟的，原因就是这里对于事件的获取是采用另起一个线程轮询策略，监听到对应的事件之后委托给对应的事件处理器（回调函数）进行处理，这种方式叫异步非阻塞。
基于以上概念延伸出来的Reactive web，实现思路大致类似。我们了解一下原生servlet的Reactive web是怎么实现的。下面是一段网上找的描述。
在服务器的并发请求数量比较大的时候,会产生很多的servlet线程(这些servlet线程在servlet容器的线程池中维护),如果每个请求需要耗费的时间比较长(比如,执行了一些IO的处理等),在之前的非异步的servlet中,这些servlet线程将会阻塞,严重耗费服务器的资源.而在servlet3.0中首次出现的异步servlet,通过一个单独的新的线程来执行这些比较耗时的任务(也可以把这些任务放到一个自己维护的线程池里),servlet线程立即返回servlet容器的servlet池以便响应其他请求,这样,在降低了系统的资源消耗的同时,也会提升系统的吞吐量
上面这种异步处理请求的方式是我们开发中常用的思路，在netty中的selector，worker概念和这个类似，下面看一下servlet中如何实现。
@WebServlet(urlPatterns = "/asyncServlet", asyncSupported = true)
public class AsyncServlet extends HttpServlet{
public void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
CommonUtil.println("开始执行servlet");
//开启异步上下文
AsyncContext asyncContext = request.startAsync();
//异步上下文设置回调函数（监听器）
asyncContext.addListener(new AsyncListener() {
@Override
public void onComplete(AsyncEvent asyncEvent) throws IOException {
ServletResponse response1 = asyncEvent.getSuppliedResponse();
response1.setContentType("text/html;charset=UTF-8");
response1.getWriter().println("complete回调函数返回输出");
CommonUtil.println("complete回调函数完成");
}
@Override
public void onTimeout(AsyncEvent asyncEvent) throws IOException {
}
@Override
public void onError(AsyncEvent asyncEvent) throws IOException {
}
@Override
public void onStartAsync(AsyncEvent asyncEvent) throws IOException {
}
});
//开启新的工作线程，释放servlet处理请求线程，工作完后回调异步上下文的监听器
new Thread(() -> {
try {
ServletResponse response1 = asyncContext.getResponse();
response1.setContentType("text/html;charset=UTF-8");
response1.getWriter().print("异步工作线程返回输出");
//出发回调函数onComplete()
CommonUtil.println("工作线程完成");
asyncContext.complete();
} catch (IOException e) {
e.printStackTrace();
}
}).start();
CommonUtil.println("释放servlet线程");
}
}
执行程序并且访问，输出
2018-06-24 09:37:18:581[http-nio-8080-exec-1] 开始执行servlet
2018-06-24 09:37:18:584[http-nio-8080-exec-1] 释放servlet线程
2018-06-24 09:37:18:585[Thread-13] 工作线程完成
2018-06-24 09:37:18:587[http-nio-8080-exec-2] complete回调函数完成明显可以看到接收请求线程，工作线程和回调函数线程都是不同的线程，这里面的回调方式，我猜测跟swing的事件处理方式可能一样，有专门线程进行轮询（没验证。。）。上面代码可以看出实现思路是开辟一个工作线程处理io等，然后触发上下文监听器回调函数，基本思路是这样实现。
这里的处理方式的好处是， 正如上面所说的，”servlet线程立即返回servlet容器的servlet池以便响应其他请求,这样,在降低了系统的资源消耗的同时,也会提升系统的吞吐量”。
ractive的编程方式，不一定能提升程序性能，但是它希望做到的是用少量线程和内存提升伸缩性，及时响应新请求。