提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  其他

当前栏目

Netty源码之Reactor模式

源码 线程 模式 IO
2023-03-07 09:50:23 时间

 

学习目标

  • 什么是Reactor模式?
  • Reactor模式由什么组成的?
  • Reactor模式解决什么问题?
  • Reactor模式线程模型有哪些?演进过程?

web处理请求架构

大多数web请求处理流程可以抽象成这几个步骤：读取(read)，解码(decode)，处理(process)，编码(encode)，发送(send)，如下图所示：

 

同时，处理web请求通常有两种架构：传统基于线程架构和事件驱动架构。

传统基于线程架构

概念

每个新连接创建一个线程来处理。对于长连接服务，如果一个client和server保持一个连接的话，有多少个client接入，server就需要创建同等的线程来处理。线程上下文切换，数据同步和内存消耗，对server来说，将是非常大的开销。

代码实现

传统基于线程架构通常采用BIO的方式来实现，代码如下：

  1. public class Server implements Runnable { 
  2.  
  3.     int port; 
  4.  
  5.     public Server(int port) { 
  6.         this.port = port; 
  7.     } 
  8.  
  9.     @Override 
  10.     public void run() { 
  11.         try { 
  12.             ServerSocket serverSocket = new ServerSocket(port); 
  13.             while (true){ 
  14.                 System.out.println("等待新连接..."); 
  15.                 new Thread(new Handler(serverSocket.accept())).start(); 
  16.             } 
  17.         } catch (IOException e) { 
  18.             e.printStackTrace(); 
  19.         } 
  20.     } 
  21.  
  22.     static class Handler implements Runnable{ 
  23.  
  24.         private Socket socket; 
  25.  
  26.         public Handler(Socket socket){ 
  27.             this.socket = socket; 
  28.         } 
  29.  
  30.         @Override 
  31.         public void run() { 
  32.             try { 
  33.                 byte[] input = new byte[1024]; 
  34.  
  35.                 this.socket.getInputStream().read(input); 
  36.                 byte[] output = process(input); 
  37.                 this.socket.getOutputStream().write(output); 
  38.                 this.socket.getOutputStream().flush(); 
  39.                 this.socket.close(); 
  40.                 System.out.println("响应完成！"); 
  41.             } catch (IOException e) { 
  42.                 e.printStackTrace(); 
  43.             } 
  44.         } 
  45.  
  46.         private byte[] process(byte[] input) { 
  47.             System.out.println("读取内容：" + new String(input)); 
  48.             return input; 
  49.         } 
  50.     } 
  51.  
  52.     public static void main(String[] args) throws InterruptedException { 
  53.         Thread thread = new Thread(new Server(2021)); 
  54.         thread.setDaemon(true); 
  55.         thread.start(); 
  56.  
  57.         synchronized (Server.class) { 
  58.             Server.class.wait(); 
  59.         } 
  60.     } 
  61. } 

为了避免线程创建销毁的开销，我们通常会采用线程池，但是同样也有很大的弊端：

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

应用场景

既然传统基于线程架构弊端这么多，它存在还有什么价值?它的应用场景是什么?

传统基于线程架构适用于连接数目比较小且一次传输大量数据的场景，比如上传，下载。

事件驱动架构

事件驱动架构：可以把线程和连接解耦，线程只用于执行事件注册的回调函数。事件驱动架构由事件生产者和事件消费者组成，前者是事件的来源，它只负责监听哪些事件发生;后者是直接处理事件或者事件发生时，响应事件的实体。

Reactor模式

什么是Reactor模式?

Reactor模式是事件驱动架构的一种具体实现方法，简而言之，就是一个单线程进行循环监听就绪IO事件，并将就绪IO事件分发给对应的回调函数。

Reactor模式由什么组成的?

Reactor模式分为两个重要组成部分，Reactor和Handler。 Reactor(反应器)：循环监听就绪IO事件，并分发给回调函数。 Handler(回调函数)：执行对应IO事件的实际业务逻辑。

Reactor模式解决什么问题?

反应器模式可以实现同步的多路复用，同步是指按照事件到达的顺序分发处理。反应器 接收来自不同的客户端的消息、请求和连接，尽管客户端是并发的，但是反应器可以按照事件到达的顺序触发回调函数。因此，Reactor模式将连接和线程解耦，不需要为每个连接创建单独线程。这个问题和C10K问题相同，提供了一个解决思路。

Reactor模式下的三种模型

单线程模型：IO事件轮询，分发(accept)和IO事件执行(read,decode,compute,encode,send)都在一个线程中完成，如下图所示：

在单线程模型下，不仅IO操作在Reactor线程上，而非IO操作(handlder中process()方法)也在Reactor线程上执行了，当非IO操作执行慢的话，这会大大延迟IO请求响应，所以应该把非IO操作拆出来，来加速Reactor线程对IO请求响应，就出现多线程模型。

单线程模型实现：

  1. // reactor 
  2. public class Reactor implements Runnable { 
  3.  
  4.     int port; 
  5.     Selector selector; 
  6.     ServerSocketChannel serverSocket; 
  7.  
  8.     public Reactor(int port) throws IOException { 
  9.         this.port = port; 
  10.         // 创建serverSocket对象 
  11.         serverSocket = ServerSocketChannel.open(); 
  12.         // 绑定端口 
  13.         serverSocket.socket().bind(new InetSocketAddress(port)); 
  14.         // 配置非阻塞 
  15.         serverSocket.configureBlocking(false); 
  16.         // 创建selector对象 
  17.         selector = Selector.open(); 
  18.         // serversocket注册到selector上，帮忙监听accpet事件 
  19.         serverSocket.register(selector, SelectionKey.OP_ACCEPT, new Acceptor(serverSocket,selector)); 
  20.         /** 还可以使用 SPI provider，来创建selector和serversocket对象 
  21.         SelectorProvider p = SelectorProvider.provider(); 
  22.         selector = p.openSelector(); 
  23.         serverSocket = p.openServerSocketChannel(); 
  24.         */ 
  25.     } 
  26.  
  27.     @Override 
  28.     public void run() { 
  29.         try { 
  30.             while (!Thread.interrupted()) { 
  31.                 System.out.println("start select event..."); 
  32.                 selector.select(); 
  33.                 Set selectedKeys = selector.selectedKeys(); 
  34.                 Iterator it = selectedKeys.iterator(); 
  35.                 while (it.hasNext()) { 
  36.                     dispatch((SelectionKey)it.next()); 
  37.                 } 
  38.                 selectedKeys.clear(); 
  39.             } 
  40.         } catch (IOException e) { 
  41.             e.printStackTrace(); 
  42.         } 
  43.     } 
  44.  
  45.     private void dispatch(SelectionKey key) { 
  46.         Runnable r = (Runnable) key.attachment(); 
  47.         if (r != null) { 
  48.             r.run(); 
  49.         } 
  50.     } 
  51.  
  52.  
  53.     public static void main(String[] args) throws IOException, InterruptedException { 
  54.         Thread thread = new Thread(new Reactor(2021)); 
  55.         thread.start(); 
  56.         synchronized (Reactor.class) { 
  57.             Reactor.class.wait(); 
  58.         } 
  59.     } 
  60. } 
  61. // acceptor调度器 
  62. public class Acceptor implements Runnable { 
  63.  
  64.     ServerSocketChannel serverSocket; 
  65.     Selector selector; 
  66.  
  67.     public Acceptor(ServerSocketChannel serverSocket,Selector selector) { 
  68.         this.serverSocket = serverSocket; 
  69.         this.selector = selector; 
  70.     } 
  71.  
  72.     @Override 
  73.     public void run() { 
  74.         try { 
  75.             SocketChannel socket = this.serverSocket.accept(); 
  76.             if (socket != null) { 
  77.                 new Handler(selector,socket); 
  78.             } 
  79.  
  80.         } catch (IOException e) { 
  81.             e.printStackTrace(); 
  82.         } 
  83.     } 
  84. } 
  85. // 回调函数handler 
  86. public class Handler implements Runnable { 
  87.  
  88.     Selector selector; 
  89.     SocketChannel socket; 
  90.     SelectionKey sk; 
  91.  
  92.     ByteBuffer input = ByteBuffer.allocate(1024); 
  93.     ByteBuffer output = ByteBuffer.allocate(1024); 
  94.     static final int READING = 0, SENDING = 1; 
  95.     int state = READING; 
  96.  
  97.  
  98.     public Handler(Selector selector, SocketChannel socket) throws IOException { 
  99.         this.selector = selector; 
  100.         this.socket = socket; 
  101.  
  102.         this.socket.configureBlocking(false); 
  103.         sk = this.socket.register(selector,0); 
  104.         sk.attach(this); 
  105.         sk.interestOps(SelectionKey.OP_READ); 
  106.         selector.wakeup(); 
  107.     } 
  108.  
  109.     @Override 
  110.     public void run() { 
  111.         try{ 
  112.             if (state == READING) { 
  113.                 read(); 
  114.             } else if (state == SENDING) { 
  115.                 send(); 
  116.             } 
  117.         } catch (IOException ex) { 
  118.             ex.printStackTrace(); 
  119.         } 
  120.     } 
  121.  
  122.     private void read() throws IOException { 
  123.         socket.read(input); 
  124.         if (inputIsComplete()) { 
  125.             // 执行业务逻辑代码 
  126.             process(); 
  127.             state = SENDING; 
  128.             // Normally also do first write now 
  129.             sk.interestOps(SelectionKey.OP_WRITE); 
  130.         } 
  131.     } 
  132.  
  133.     private void send() throws IOException { 
  134.         socket.write(output); 
  135.         socket.close(); 
  136.         if (outputIsComplete()) sk.cancel(); 
  137.     } 
  138.  
  139.     boolean inputIsComplete() { return true;} 
  140.  
  141.     boolean outputIsComplete() {return true;} 
  142.     // 处理非IO操作(业务逻辑代码) 
  143.     void process(){ 
  144.         String msg = new String(input.array()); 
  145.         System.out.println("读取内容：" + msg); 
  146.         output.put(msg.getBytes()); 
  147.         output.flip(); 
  148.     } 
  149. } 
  • 多线程模型：与单线程模型不同的是添加一个业务线程池，将非IO操作(业务逻辑处理)交给业务线程池来处理，提高Reactor线程的IO响应，如图所示：

 

在多线程模型下，虽然将非IO操作拆出去了，但是所有IO操作都在Reactor单线程中完成的。在高负载、高并发场景下，也会成为瓶颈，于是对Reactor单线程进行了优化，出现了主从线程模型。

多线程模型实现：

  1. public class Reactor implements Runnable { 
  2.  
  3.     int port; 
  4.     Selector selector; 
  5.     ServerSocketChannel serverSocket; 
  6.  
  7.  
  8.     public Reactor(int port) throws IOException { 
  9.         this.port = port; 
  10.  
  11.         // 创建serverSocket对象 
  12.         serverSocket = ServerSocketChannel.open(); 
  13.         // 绑定端口 
  14.         serverSocket.socket().bind(new InetSocketAddress(port)); 
  15.         // 配置非阻塞 
  16.         serverSocket.configureBlocking(false); 
  17.  
  18.         // 创建selector对象 
  19.         selector = Selector.open(); 
  20.         // serversocket注册到selector上，帮忙监听accpet事件 
  21.         serverSocket.register(selector, SelectionKey.OP_ACCEPT, new Acceptor("Acceptor",serverSocket,selector)); 
  22.  
  23.         /** 还可以使用 SPI provider，来创建selector和serversocket对象 
  24.         SelectorProvider p = SelectorProvider.provider(); 
  25.         selector = p.openSelector(); 
  26.         serverSocket = p.openServerSocketChannel(); 
  27.         */ 
  28.     } 
  29.  
  30.     @Override 
  31.     public void run() { 
  32.         try { 
  33.             while (!Thread.interrupted()) { 
  34.                 System.out.println("start select event..."); 
  35.                 selector.select(); 
  36.                 Set selectedKeys = selector.selectedKeys(); 
  37.                 Iterator it = selectedKeys.iterator(); 
  38.                 while (it.hasNext()) { 
  39.                     dispatch((SelectionKey)it.next()); 
  40.                 } 
  41.                 selectedKeys.clear(); 
  42.             } 
  43.         } catch (IOException e) { 
  44.             e.printStackTrace(); 
  45.         } 
  46.     } 
  47.  
  48.     private void dispatch(SelectionKey key) { 
  49.         SelfRunable r = (SelfRunable) key.attachment(); 
  50.         if (r != null) { 
  51.             System.out.println("dispatch to " + r.getName() + "===="); 
  52.             r.run(); 
  53.         } 
  54.     } 
  55.  
  56.  
  57.     public static void main(String[] args) throws IOException, InterruptedException { 
  58.  
  59.         Thread thread = new Thread(new Reactor(2021)); 
  60.         thread.start(); 
  61.  
  62.         synchronized (Reactor.class) { 
  63.             Reactor.class.wait(); 
  64.         } 
  65.  
  66.  
  67.     } 
  68. } 
  69.  
  70. public class Acceptor implements SelfRunable { 
  71.     ServerSocketChannel serverSocket; 
  72.     Selector selector; 
  73.     String name; 
  74.     public Acceptor(String name, ServerSocketChannel serverSocket,Selector selector) { 
  75.         this.name = name; 
  76.         this.serverSocket = serverSocket; 
  77.         this.selector = selector; 
  78.     } 
  79.  
  80.     @Override 
  81.     public void run() { 
  82.         try { 
  83.             SocketChannel socket = this.serverSocket.accept(); 
  84.             if (socket != null) { 
  85.                 new Handler("handler_" + ((InetSocketAddress)socket.getLocalAddress()).getPort(), selector,socket); 
  86.             } 
  87.  
  88.         } catch (IOException e) { 
  89.             e.printStackTrace(); 
  90.         } 
  91.     } 
  92.  
  93.     @Override 
  94.     public String getName() { 
  95.         return this.name; 
  96.     } 
  97. } 
  98.  
  99. public class Handler implements SelfRunable { 
  100.     String name; 
  101.     Selector selector; 
  102.     SocketChannel socket; 
  103.     SelectionKey sk; 
  104.     ByteBuffer input = ByteBuffer.allocate(1024); 
  105.     ByteBuffer output = ByteBuffer.allocate(1024); 
  106.     static final int READING = 0, SENDING = 1,  PROCESSING = 3; 
  107.     volatile int state = READING; 
  108.     static ExecutorService poolExecutor = Executors.newFixedThreadPool(5); 
  109.  
  110.     public Handler(String name, Selector selector, SocketChannel socket) throws IOException { 
  111.         this.selector = selector; 
  112.         this.socket = socket; 
  113.         this.name = name; 
  114.  
  115.         this.socket.configureBlocking(false); 
  116.         sk = this.socket.register(selector,0); 
  117.         sk.attach(this); 
  118.         sk.interestOps(SelectionKey.OP_READ); 
  119.         selector.wakeup(); 
  120.     } 
  121.  
  122.     @Override 
  123.     public void run() { 
  124.         try{ 
  125.             System.out.println("state:" + state); 
  126.             if (state == READING) { 
  127.                 read(); 
  128.             } else if (state == SENDING) { 
  129.                 send(); 
  130.             } 
  131.         } catch (IOException ex) { 
  132.             ex.printStackTrace(); 
  133.         } 
  134.     } 
  135.  
  136.     synchronized void read() throws IOException { 
  137.         socket.read(input); 
  138.         if (inputIsComplete()) { 
  139.             state = PROCESSING; 
  140.            poolExecutor.execute(new Processer()); 
  141.         } 
  142.     } 
  143.  
  144.     synchronized void processAndHandOff() { 
  145.         System.out.println("processAndHandOff========="); 
  146.         process(); 
  147.         state = SENDING; // or rebind attachment 
  148.         sk.interestOps(SelectionKey.OP_WRITE); 
  149.         selector.wakeup(); 
  150.         System.out.println("processAndHandOff finish ! ========="); 
  151.     } 
  152.  
  153.     private void send() throws IOException { 
  154.         System.out.println("start send ..."); 
  155.         socket.write(output); 
  156.         socket.close(); 
  157.         System.out.println("start send finish!"); 
  158.         if (outputIsComplete()) sk.cancel(); 
  159.     } 
  160.  
  161.     boolean inputIsComplete() { return true;} 
  162.  
  163.     boolean outputIsComplete() {return true;} 
  164.  
  165.     void process(){ 
  166.         String msg = new String(input.array()); 
  167.         System.out.println("读取内容：" + msg); 
  168.         output.put(msg.getBytes()); 
  169.         output.flip(); 
  170.     } 
  171.  
  172.     @Override 
  173.     public String getName() { 
  174.         return this.name; 
  175.     } 
  176.  
  177.     class Processer implements Runnable { 
  178.         public void run() { processAndHandOff(); } 
  179.     } 
  180. } 
  • 主从线程模型： 相比多线程模型而言，对于多核cpu，为了充分利用资源，将Reactor拆分成了mainReactor 和 subReactor，但是，主从线程模型也有弊端，不适合大量数据传输。 mainReactor：负责监听接收(accpet)新连接，将新连接后续操作交给subReactor来处理，通常由一个线程处理。 subReactor： 负责处理IO的读写操作，通常由多个线程处理。 非IO操作依然由业务线程池来处理。

主从线程模型实现：

  1. public class Reactor implements Runnable { 
  2.  
  3.     int port; 
  4.     Selector selector; 
  5.     ServerSocketChannel serverSocket; 
  6.     int SUBREACTOR_SIZE = 1; 
  7.     SubReactor[] subReactorPool = new SubReactor[SUBREACTOR_SIZE]; 
  8.  
  9.  
  10.     public Reactor(int port) throws IOException { 
  11.         this.port = port; 
  12.  
  13.         // 创建serverSocket对象 
  14.         serverSocket = ServerSocketChannel.open(); 
  15.         // 绑定端口 
  16.         serverSocket.socket().bind(new InetSocketAddress(port)); 
  17.         // 配置非阻塞 
  18.         serverSocket.configureBlocking(false); 
  19.  
  20.         // 创建selector对象 
  21.         selector = Selector.open(); 
  22.         // serversocket注册到selector上，帮忙监听accpet事件 
  23.         serverSocket.register(selector, SelectionKey.OP_ACCEPT, new Acceptor("Acceptor",serverSocket,subReactorPool)); 
  24.  
  25.         // 初始化subreactor pool 
  26.         initSubReactorPool(); 
  27.  
  28.  
  29.         /** 还可以使用 SPI provider，来创建selector和serversocket对象 
  30.         SelectorProvider p = SelectorProvider.provider(); 
  31.         selector = p.openSelector(); 
  32.         serverSocket = p.openServerSocketChannel(); 
  33.         */ 
  34.     } 
  35.  
  36.     @Override 
  37.     public void run() { 
  38.         try { 
  39.             while (!Thread.interrupted()) { 
  40.                 System.out.println("mainReactor start select event..."); 
  41.                 selector.select(); 
  42.                 Set selectedKeys = selector.selectedKeys(); 
  43.                 Iterator it = selectedKeys.iterator(); 
  44.                 while (it.hasNext()) { 
  45.                     dispatch((SelectionKey)it.next()); 
  46.                 } 
  47.                 selectedKeys.clear(); 
  48.             } 
  49.         } catch (IOException e) { 
  50.             e.printStackTrace(); 
  51.         } 
  52.     } 
  53.  
  54.     void initSubReactorPool() { 
  55.         try { 
  56.             for (int i = 0; i < SUBREACTOR_SIZE; i++) { 
  57.                 subReactorPool[i] = new SubReactor("SubReactor" + i); 
  58.             } 
  59.         } catch (IOException ex) { /* ... */ } 
  60.     } 
  61.  
  62.     private void dispatch(SelectionKey key) { 
  63.         SelfRunable r = (SelfRunable) key.attachment(); 
  64.         if (r != null) { 
  65.             System.out.println("mainReactor dispatch to " + r.getName() + "===="); 
  66.             r.run(); 
  67.         } 
  68.     } 
  69.  
  70.  
  71.     public static void main(String[] args) throws IOException, InterruptedException { 
  72.  
  73.         Thread thread = new Thread(new Reactor(2021)); 
  74.         thread.start(); 
  75.  
  76.         synchronized (Reactor.class) { 
  77.             Reactor.class.wait(); 
  78.         } 
  79.     } 
  80. } 
  81.  
  82. public class SubReactor implements SelfRunable { 
  83.  
  84.     private Selector selector; 
  85.     private String name; 
  86.     private List<SelfRunable> task = new ArrayList<SelfRunable>(); 
  87.  
  88.     public SubReactor(String name) throws IOException { 
  89.         this.name = name; 
  90.         selector = Selector.open(); 
  91.         new Thread(this).start(); 
  92.     } 
  93.  
  94.     @Override 
  95.     public String getName() { 
  96.         return this.name; 
  97.     } 
  98.  
  99.     @Override 
  100.     public void run() { 
  101.         try { 
  102.             while (!Thread.interrupted()) { 
  103.                 System.out.println("subReactor start select event..."); 
  104.                 selector.select(5000); 
  105.                 Set selectedKeys = selector.selectedKeys(); 
  106.                 Iterator it = selectedKeys.iterator(); 
  107.                 while (it.hasNext()) { 
  108.                     dispatch((SelectionKey)it.next()); 
  109.                 } 
  110.                 selectedKeys.clear(); 
  111.  
  112.             } 
  113.         } catch (IOException e) { 
  114.             e.printStackTrace(); 
  115.         } 
  116.     } 
  117.  
  118.     private void dispatch(SelectionKey key) { 
  119.         SelfRunable r = (SelfRunable) key.attachment(); 
  120.         if (r != null) { 
  121.             System.out.println("subReactor dispatch to " + r.getName() + "===="); 
  122.             r.run(); 
  123.         } 
  124.     } 
  125.  
  126.     public Selector getSelector(){ 
  127.         return this.selector; 
  128.     } 
  129.  
  130.     public void submit(SelfRunable runnable) { 
  131.         task.add(runnable); 
  132.     } 
  133.  
  134. } 
  135.  
  136. public class Acceptor implements SelfRunable { 
  137.  
  138.     int next = 0; 
  139.     String name; 
  140.     SubReactor[] subReactorPool; 
  141.     ServerSocketChannel serverSocket; 
  142.  
  143.     public Acceptor(String name, ServerSocketChannel serverSocket,SubReactor[] subReactorPool) { 
  144.         this.name = name; 
  145.         this.serverSocket = serverSocket; 
  146.         this.subReactorPool = subReactorPool; 
  147.     } 
  148.  
  149.     @Override 
  150.     public void run() { 
  151.         try { 
  152.             SocketChannel socket = this.serverSocket.accept(); 
  153.             if (socket != null) { 
  154.                 new Handler("handler", subReactorPool[next].getSelector(),socket); 
  155.             } 
  156.             if (++next == subReactorPool.length) {next=0;} 
  157.  
  158.         } catch (IOException e) { 
  159.             e.printStackTrace(); 
  160.         } 
  161.     } 
  162.  
  163.     @Override 
  164.     public String getName() { 
  165.         return this.name; 
  166.     } 
  167. } 
  168.  
  169. public class Handler implements SelfRunable { 
  170.  
  171.     String name; 
  172.     Selector selector; 
  173.     SocketChannel socket; 
  174.     SelectionKey sk; 
  175.  
  176.     ByteBuffer input = ByteBuffer.allocate(1024); 
  177.     ByteBuffer output = ByteBuffer.allocate(1024); 
  178.     static final int READING = 0, SENDING = 1,  PROCESSING = 3; 
  179.     volatile int state = READING; 
  180.  
  181.     static ExecutorService poolExecutor = Executors.newFixedThreadPool(5); 
  182.  
  183.     public Handler(String name, Selector selector, SocketChannel socket) throws IOException { 
  184.         this.selector = selector; 
  185.         this.socket = socket; 
  186.         this.name = name; 
  187.  
  188.         this.socket.configureBlocking(false); 
  189.         sk = this.socket.register(this.selector,0); 
  190.         sk.attach(this); 
  191.         sk.interestOps(SelectionKey.OP_READ); 
  192.         selector.wakeup(); 
  193.     } 
  194.  
  195.     @Override 
  196.     public void run() { 
  197.         try{ 
  198.             System.out.println("state:" + state); 
  199.             if (state == READING) { 
  200.                 read(); 
  201.             } else if (state == SENDING) { 
  202.                 send(); 
  203.             } 
  204.         } catch (IOException ex) { 
  205.             ex.printStackTrace(); 
  206.         } 
  207.     } 
  208.  
  209.     synchronized void read() throws IOException { 
  210.         socket.read(input); 
  211.         if (inputIsComplete()) { 
  212.             state = PROCESSING; 
  213.            poolExecutor.execute(new Processer()); 
  214.         } 
  215.     } 
  216.  
  217.     synchronized void processAndHandOff() { 
  218.         System.out.println("processAndHandOff========="); 
  219.         process(); 
  220.         state = SENDING; // or rebind attachment 
  221.         sk.interestOps(SelectionKey.OP_WRITE); 
  222.         selector.wakeup(); 
  223.         System.out.println("processAndHandOff finish ! ========="); 
  224.     } 
  225.  
  226.     private void send() throws IOException { 
  227.         System.out.println("start send ..."); 
  228.         socket.write(output); 
  229.         socket.close(); 
  230.         System.out.println("start send finish!"); 
  231.         if (outputIsComplete()) sk.cancel(); 
  232.     } 
  233.  
  234.     boolean inputIsComplete() { return true;} 
  235.  
  236.     boolean outputIsComplete() {return true;} 
  237.  
  238.     void process(){ 
  239.         String msg = new String(input.array()); 
  240.         System.out.println("读取内容：" + msg); 
  241.         output.put(msg.getBytes()); 
  242.         output.flip(); 
  243.     } 
  244.  
  245.     @Override 
  246.     public String getName() { 
  247.         return this.name; 
  248.     } 
  249.  
  250.     class Processer implements Runnable { 
  251.         public void run() { processAndHandOff(); } 
  252.     } 
  253. } 

Reactor线程模型演进

模型

简介

弊端

单线程模型

IO/非IO操作都在Reactor单线程中完成

非IO操作执行慢，影响IO操作响应延迟

多线程模型

拆分非IO操作交给业务线程池执行，IO操作由Reator单线程执行

高并发，高负载场景下，Reactor单线程会成为瓶颈

主从线程模型

Reactor单线程拆分为mainReactor和subReactor

不适合大量数据传输

Netty线程模型

Reactor主从线程模型-抽象模型

  • 创建ServerSocketChannel过程(创建channel，配置非阻塞)
  • ServerSocketChannel注册到mainReactor的selector对象上，监听accept事件
  • mainReactor的selector监听到新连接SocketChannel，将SocketChannel注册到subReactor的selector对象上，监听read/write事件
  • subReactor的selector监听到read/write事件，移交给业务线程池(对应netty的pipeline)

Netty线程模型

我们再好好看看mainReactor和subReactor，其实这两个类功能非常相似，所以Netty将mainReactor和subReactor统一成了EventLoop。对于Netty零基础的，请参考这个Reactor主从线程模型-抽象模型和下面这张图来理解EventLoop。

 

 

相关文章