Reactor详解

偏执的太偏执、 2022-11-30 12:42 170阅读 0赞

> 1.  reactor 是什么
> 2.  为何要用，能解决什么问题
> 3.  如何用，更好的方式
> 4.  其他事件处理模式

# 一、Reactor 是什么 #

关于reactor 是什么，我们先从wiki上看下:

> The reactor design pattern is an event handling pattern for handling service requests delivered concurrently to a service handler by one or more inputs. The service handler then demultiplexes the incoming requests and dispatches them synchronously to the associated request handlers.

翻译：

reactor设计模式是一种事件处理模式，用于处理通过一个或多个输入同时交付给服务处理程序的服务请求。 然后，服务处理程序对传入的请求进行多路分解，并将它们同步分发到关联的请求处理程序。

从上述文字中我们可以看出以下关键点 ：

> 1.  事件驱动（event handling）
> 2.  可以处理一个或多个输入源（one or more inputs）
> 3.  通过Service Handler同步的将输入事件（Event）采用多路复用分发给相应的Request Handler（多个）处理

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70][]

自POSA2 中的关于Reactor Pattern 介绍中，我们了解了Reactor 的处理方式:

> 1.  同步的等待多个事件源到达（采用select()实现）
> 2.  将事件多路分解以及分配相应的事件服务进行处理，这个分派采用server集中处理（dispatch）
> 3.  分解的事件以及对应的事件服务应用从分派服务中分离出去（handler）

关于Reactor Pattern 的OMT 类图设计:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 1][]

# 二、为何要用Reactor #

常见的网络服务中，如果每一个客户端都维持一个与登陆服务器的连接。那么服务器将维护多个和客户端的连接以出来和客户端的contnect 、read、write ，特别是对于长链接的服务，有多少个c端，就需要在s端维护同等的IO连接。这对服务器来说是一个很大的开销。

## 1、BIO ##

比如我们采用BIO的方式来维护和客户端的连接：

1.  `// 主线程维护连接`
2.  `  public void run() {`
3.  `      try {`
4.  `          while (true) {`
5.  `              Socket socket = serverSocket.accept();`
6.  `              //提交线程池处理`
7.  `              executorService.submit(new Handler(socket));`
8.  `          }`
9.  `      } catch (Exception e) {`
10. `          e.printStackTrace();`
11. `      }`
12. `  }`
13. ``
14. `  // 处理读写服务`
15. `  class Handler implements Runnable {`
16. `      public void run() {`
17. `          try {`
18. `              //获取Socket的输入流，接收数据`
19. `              BufferedReader buf = new BufferedReader(new InputStreamReader(socket.getInputStream()));`
20. `              String readData = buf.readLine();`
21. `              while (readData != null) {`
22. `                  readData = buf.readLine();`
23. `                  System.out.println(readData);`
24. `              }`
25. `          } catch (Exception e) {`
26. `              e.printStackTrace();`
27. `          }`
28. `      }`
29. `  }`

很明显，为了避免资源耗尽，我们采用线程池的方式来处理读写服务。但是这么做依然有很明显的弊端：

> 1.  同步阻塞IO，读写阻塞，线程等待时间过长
> 2.  在制定线程策略的时候，只能根据CPU的数目来限定可用线程资源，不能根据连接并发数目来制定，也就是连接有限制。否则很难保证对客户端请求的高效和公平。
> 3.  多线程之间的上下文切换，造成线程使用效率并不高，并且不易扩展
> 4.  状态数据以及其他需要保持一致的数据，需要采用并发同步控制

## 2、NIO ##

那么可以有其他方式来更好的处理么，我们可以采用NIO来处理，NIO中支持的基本机制:

> 1.  非阻塞的IO读写
> 2.  基于IO事件进行分发任务，同时支持对多个fd的监听

我们看下NIO 中实现相关方式:

1.  `public NIOServer(int port) throws Exception {`
2.  `      selector = Selector.open();`
3.  `      serverSocket = ServerSocketChannel.open();`
4.  `      serverSocket.socket().bind(new InetSocketAddress(port));`
5.  `      serverSocket.configureBlocking(false);`
6.  `      serverSocket.register(selector, SelectionKey.OP_ACCEPT);`
7.  `  }`
8.  ``
9.  `  @Override`
10. `  public void run() {`
11. `      while (!Thread.interrupted()) {`
12. `          try {`
13. `              //阻塞等待事件`
14. `              selector.select();`
15. `              // 事件列表`
16. `              Set selected = selector.selectedKeys();`
17. `              Iterator it = selected.iterator();`
18. `              while (it.hasNext()) {`
19. `                  it.remove();`
20. `                  //分发事件`
21. `                  dispatch((SelectionKey) (it.next()));`
22. `              }`
23. `          } catch (Exception e) {`
24. ``
25. `          }`
26. `      }`
27. `  }`
28. ``
29. `  private void dispatch(SelectionKey key) throws Exception {`
30. `      if (key.isAcceptable()) {`
31. `          register(key);//新链接建立，注册`
32. `      } else if (key.isReadable()) {`
33. `          read(key);//读事件处理`
34. `      } else if (key.isWritable()) {`
35. `          wirete(key);//写事件处理`
36. `      }`
37. `  }`
38. ``
39. `  private void register(SelectionKey key) throws Exception {`
40. `      ServerSocketChannel server = (ServerSocketChannel) key`
41. `              .channel();`
42. `      // 获得和客户端连接的通道`
43. `      SocketChannel channel = server.accept();`
44. `      channel.configureBlocking(false);`
45. `      //客户端通道注册到selector 上`
46. `      channel.register(this.selector, SelectionKey.OP_READ);`
47. `  }`

我们可以看到上述的NIO例子已经差不多拥有reactor的影子了

> 1.  基于事件驱动-> selector（支持对多个socketChannel的监听）
> 2.  统一的事件分派中心-> dispatch
> 3.  事件处理服务-> read & write

事实上NIO已经解决了上述BIO暴露的1&2问题了，服务器的并发客户端有了量的提升，不再受限于一个客户端一个线程来处理，而是一个线程可以维护多个客户端（selector 支持对多个socketChannel 监听）。

但这依然不是一个完善的Reactor Pattern ,首先Reactor 是一种设计模式，好的模式应该是支持更好的扩展性，显然以上的并不支持，另外好的Reactor Pattern 必须有以下特点：

> 1.  更少的资源利用，通常不需要一个客户端一个线程
> 2.  更少的开销，更少的上下文切换以及locking
> 3.  能够跟踪服务器状态
> 4.  能够管理handler 对event的绑定

那么好的Reactor Pattern应该是怎样的？

# 三、Reactor #

在应用Java NIO构建Reactor Pattern中，大神 Doug Lea（让人无限景仰的java 大神）在“[Scalable IO in Java][]”中给了很好的阐述。我们采用大神介绍的3种Reactor 来分别介绍。

首先我们基于Reactor Pattern 处理模式中，定义以下三种角色:

>  *  **Reactor** 将I/O事件分派给对应的Handler
>  *  **Acceptor** 处理客户端新连接，并分派请求到处理器链中
>  *  **Handlers** 执行非阻塞读/写 任务

## 1、单Reactor单线程模型 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 2][]

我们看代码的实现方式:

1.  `/**`
2.  `    * 等待事件到来，分发事件处理`
3.  `    */`
4.  `  class Reactor implements Runnable {`
5.  ``
6.  `      private Reactor() throws Exception {`
7.  ``
8.  `          SelectionKey sk =`
9.  `                  serverSocket.register(selector,`
10. `                          SelectionKey.OP_ACCEPT);`
11. `          // attach Acceptor 处理新连接`
12. `          sk.attach(new Acceptor());`
13. `      }`
14. ``
15. `      public void run() {`
16. `          try {`
17. `              while (!Thread.interrupted()) {`
18. `                  selector.select();`
19. `                  Set selected = selector.selectedKeys();`
20. `                  Iterator it = selected.iterator();`
21. `                  while (it.hasNext()) {`
22. `                      it.remove();`
23. `                      //分发事件处理`
24. `                      dispatch((SelectionKey) (it.next()));`
25. `                  }`
26. `              }`
27. `          } catch (IOException ex) {`
28. `              //do something`
29. `          }`
30. `      }`
31. ``
32. `      void dispatch(SelectionKey k) {`
33. `          // 若是连接事件获取是acceptor`
34. `          // 若是IO读写事件获取是handler`
35. `          Runnable runnable = (Runnable) (k.attachment());`
36. `          if (runnable != null) {`
37. `              runnable.run();`
38. `          }`
39. `      }`
40. ``
41. `  }`
42. ` `

1.  `/**`
2.  `    * 连接事件就绪,处理连接事件`
3.  `    */`
4.  `  class Acceptor implements Runnable {`
5.  `      @Override`
6.  `      public void run() {`
7.  `          try {`
8.  `              SocketChannel c = serverSocket.accept();`
9.  `              if (c != null) {// 注册读写`
10. `                  new Handler(c, selector);`
11. `              }`
12. `          } catch (Exception e) {`
13. ``
14. `          }`
15. `      }`
16. `  }`

这是最基本的单Reactor单线程模型。其中Reactor线程，负责多路分离套接字，有新连接到来触发connect 事件之后，交由Acceptor进行处理，有IO读写事件之后交给hanlder 处理。

Acceptor主要任务就是构建handler ，在获取到和client相关的SocketChannel之后 ，绑定到相应的hanlder上，对应的SocketChannel有读写事件之后，基于Reactor 分发,hanlder就可以处理了（所有的IO事件都绑定到selector上，有Reactor分发）。

该模型 适用于处理器链中业务处理组件能快速完成的场景。不过，这种单线程模型不能充分利用多核资源，所以实际使用的不多。

### 2、单Reactor多线程模型 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 3][]

相对于第一种单线程的模式来说，在处理业务逻辑，也就是获取到IO的读写事件之后，交由线程池来处理，这样可以减小主reactor的性能开销，从而更专注的做事件分发工作了，从而提升整个应用的吞吐。

我们看下实现方式：

1.  `/**`
2.  `    * 多线程处理读写业务逻辑`
3.  `    */`
4.  `  class MultiThreadHandler implements Runnable {`
5.  `      public static final int READING = 0, WRITING = 1;`
6.  `      int state;`
7.  `      final SocketChannel socket;`
8.  `      final SelectionKey sk;`
9.  ``
10. `      //多线程处理业务逻辑`
11. `      ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());`
12. ``
13. ``
14. `      public MultiThreadHandler(SocketChannel socket, Selector sl) throws Exception {`
15. `          this.state = READING;`
16. `          this.socket = socket;`
17. `          sk = socket.register(selector, SelectionKey.OP_READ);`
18. `          sk.attach(this);`
19. `          socket.configureBlocking(false);`
20. `      }`
21. ``
22. `      @Override`
23. `      public void run() {`
24. `          if (state == READING) {`
25. `              read();`
26. `          } else if (state == WRITING) {`
27. `              write();`
28. `          }`
29. `      }`
30. ``
31. `      private void read() {`
32. `          //任务异步处理`
33. `          executorService.submit(() -> process());`
34. ``
35. `          //下一步处理写事件`
36. `          sk.interestOps(SelectionKey.OP_WRITE);`
37. `          this.state = WRITING;`
38. `      }`
39. ``
40. `      private void write() {`
41. `          //任务异步处理`
42. `          executorService.submit(() -> process());`
43. ``
44. `          //下一步处理读事件`
45. `          sk.interestOps(SelectionKey.OP_READ);`
46. `          this.state = READING;`
47. `      }`
48. ``
49. `      /**`
50. `        * task 业务处理`
51. `        */`
52. `      public void process() {`
53. `          //do IO ,task,queue something`
54. `      }`
55. `  }`

## 3、多Reactor多线程模型 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 4][]

第三种模型比起第二种模型，是将Reactor分成两部分，

> 1.  mainReactor负责监听server socket，用来处理新连接的建立，将建立的socketChannel指定注册给subReactor。
> 2.  subReactor维护自己的selector, 基于mainReactor 注册的socketChannel多路分离IO读写事件，读写网 络数据，对业务处理的功能，另其扔给worker线程池来完成。

我们看下实现方式:

1.  `/**`
2.  `    * 多work 连接事件Acceptor,处理连接事件`
3.  `    */`
4.  `  class MultiWorkThreadAcceptor implements Runnable {`
5.  ``
6.  `      // cpu线程数相同多work线程`
7.  `      int workCount =Runtime.getRuntime().availableProcessors();`
8.  `      SubReactor[] workThreadHandlers = new SubReactor[workCount];`
9.  `      volatile int nextHandler = 0;`
10. ``
11. `      public MultiWorkThreadAcceptor() {`
12. `          this.init();`
13. `      }`
14. ``
15. `      public void init() {`
16. `          nextHandler = 0;`
17. `          for (int i = 0; i < workThreadHandlers.length; i++) {`
18. `              try {`
19. `                  workThreadHandlers[i] = new SubReactor();`
20. `              } catch (Exception e) {`
21. `              }`
22. ``
23. `          }`
24. `      }`
25. ``
26. `      @Override`
27. `      public void run() {`
28. `          try {`
29. `              SocketChannel c = serverSocket.accept();`
30. `              if (c != null) {// 注册读写`
31. `                  synchronized (c) {`
32. `                      // 顺序获取SubReactor，然后注册channel `
33. `                      SubReactor work = workThreadHandlers[nextHandler];`
34. `                      work.registerChannel(c);`
35. `                      nextHandler++;`
36. `                      if (nextHandler >= workThreadHandlers.length) {`
37. `                          nextHandler = 0;`
38. `                      }`
39. `                  }`
40. `              }`
41. `          } catch (Exception e) {`
42. `          }`
43. `      }`
44. `  }`

1.   
2.  `  /**`
3.  `    * 多work线程处理读写业务逻辑`
4.  `    */`
5.  `  class SubReactor implements Runnable {`
6.  `      final Selector mySelector;`
7.  ``
8.  `      //多线程处理业务逻辑`
9.  `      int workCount =Runtime.getRuntime().availableProcessors();`
10. `      ExecutorService executorService = Executors.newFixedThreadPool(workCount);`
11. ``
12. ``
13. `      public SubReactor() throws Exception {`
14. `          // 每个SubReactor 一个selector `
15. `          this.mySelector = SelectorProvider.provider().openSelector();`
16. `      }`
17. ``
18. `      /**`
19. `        * 注册chanel`
20. `        *`
21. `        * @param sc`
22. `        * @throws Exception`
23. `        */`
24. `      public void registerChannel(SocketChannel sc) throws Exception {`
25. `          sc.register(mySelector, SelectionKey.OP_READ | SelectionKey.OP_CONNECT);`
26. `      }`
27. ``
28. `      @Override`
29. `      public void run() {`
30. `          while (true) {`
31. `              try {`
32. `              //每个SubReactor 自己做事件分派处理读写事件`
33. `                  selector.select();`
34. `                  Set<SelectionKey> keys = selector.selectedKeys();`
35. `                  Iterator<SelectionKey> iterator = keys.iterator();`
36. `                  while (iterator.hasNext()) {`
37. `                      SelectionKey key = iterator.next();`
38. `                      iterator.remove();`
39. `                      if (key.isReadable()) {`
40. `                          read();`
41. `                      } else if (key.isWritable()) {`
42. `                          write();`
43. `                      }`
44. `                  }`
45. ``
46. `              } catch (Exception e) {`
47. ``
48. `              }`
49. `          }`
50. `      }`
51. ``
52. `      private void read() {`
53. `          //任务异步处理`
54. `          executorService.submit(() -> process());`
55. `      }`
56. ``
57. `      private void write() {`
58. `          //任务异步处理`
59. `          executorService.submit(() -> process());`
60. `      }`
61. ``
62. `      /**`
63. `        * task 业务处理`
64. `        */`
65. `      public void process() {`
66. `          //do IO ,task,queue something`
67. `      }`
68. `  }`
69. ``

第三种模型中，我们可以看到，mainReactor 主要是用来处理网络IO 连接建立操作，通常一个线程就可以处理，而subReactor主要做和建立起来的socket做数据交互和事件业务处理操作，它的个数上一般是和CPU个数等同，每个subReactor一个县城来处理。

此种模型中，每个模块的工作更加专一，耦合度更低，性能和稳定性也大量的提升，支持的可并发客户端数量可达到上百万级别。

关于此种模型的应用，目前有很多优秀的矿建已经在应用了，比如mina 和netty 等。上述中去掉线程池的第三种形式的变种，也 是Netty NIO的默认模式。下一节我们将着重讲解netty的架构模式。

# 四、事件处理模式 #

在 [Douglas Schmidt][] 的大作《POSA2》中有关于事件处理模式的介绍，其中有四种事件处理模式:

> 1.  **Reactor**　　
> 2.  **Proactor**　　
> 3.  **Asynchronous Completion Token**　　
> 4.  **Acceptor-Connector**

## 1. **Proactor** ##

本文介绍的**Reactor**就是其中一种，而**Proactor**的整体结构和reacotor的处理方式大同小异，不同的是**Proactor**采用的是异步非阻塞IO的方式实现，对数据的读写由异步处理，无需用户线程来处理，服务程序更专注于业务事件的处理，而非IO阻塞。

## 2. **Asynchronous Completion Token** ##

简单来说，**ACT**就是应对应用程序异步调用服务操作，并处理相应的服务完成事件。从token这个字面意思，我们大概就能了解到，它是一种状态的保持和传递。

比如，通常应用程序会有调用第三方服务的需求，一般是业务线程请求都到，需要第三方资源的时候，去同步的发起第三方请求，而为了提升应用性能，需要异步的方式发起请求，但异步请求的话，等数据到达之后，此时的我方应用程序的语境以及上下文信息已经发生了变化，你没办法去处理。

**ACT** 解决的就是这个问题，采用了一个token的方式记录异步发送前的信息，发送给接受方，接受方回复的时候再带上这个token，此时就能恢复业务的调用场景。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 5][]

上图中我们可以看到在client processing 这个阶段，客户端是可以继续处理其他业务逻辑的，不是阻塞状态。service 返回期间会带上token信息。

## 3. **Acceptor-Connector** ##

**Acceptor-Connector**是于Reactor的结合，也可以看成是一种变种，它看起来很像上面介绍的Reactor第三种实现方式，但又有本质的不同。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 6][]

**Acceptor-Connector**模式是将网络中对等服务的连接和初始化分开处理，使系统中的连接建立及服务一旦服务初始化后就分开解除耦合。连接器*主动地*建立到远地接受器组件的连接，并初始化服务处理器来处理在连接上交换的数据。同样地，接受器*被动地*等待来自远地连接器的连接请求，在这样的请求到达时建立连接，并初始化服务处理器来处理在连接上交换的数据。随后已初始化的服务处理器执行应用特有的处理，并通过连接器和接受器组件建立的连接来进行通信。

这么处理的好处是:

> 1.  一般而言，用于连接建立和服务初始化的策略变动的频度要远小于应用服务实现和通信协议。
> 2.  容易增加新类型的服务、新的服务实现和新的通信协议，而又不影响现有的连接建立和服务初始化软件。比如采用IPX/SPX通信协议或者TCP协议。
> 3.  连接角色和通信角色的去耦合，连接角色只管发起连接 vs. 接受连接。通信角色只管数据交互。
> 4.  将程序员与低级网络编程API（像socket或TLI）类型安全性的缺乏屏蔽开来。业务开发关系底层通信

转载：[https://my.oschina.net/u/1859679/blog/1844109][https_my.oschina.net_u_1859679_blog_1844109]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70]: /images/20221123/46013dd90f89480fb3ed0f02898c64c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 1]: /images/20221123/c7da1eac8ec04120a4fc9df82c808399.png
[Scalable IO in Java]: http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 2]: /images/20221123/8f5f83d7e4354a3ba29726c515cb253a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 3]: /images/20221123/46ef5aaf68624dffae8104a548415c02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 4]: /images/20221123/f15acc0f64984944b18ec06d95e9d013.png
[Douglas Schmidt]: https://book.douban.com/search/Douglas%20Schmidt%20%20%E7%AD%89%E8%91%97
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 5]: /images/20221123/6762ece2f9914db086abc33869b80250.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Jpbmd4dWVzaXlhbmc_size_16_color_FFFFFF_t_70 6]: /images/20221123/bfc249e870534ee6a1bbc371e8407f94.png
[https_my.oschina.net_u_1859679_blog_1844109]: https://my.oschina.net/u/1859679/blog/1844109