modify net work

Author: h2pl

docs/java/network-programming/Java网络与NIO总结.md

@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [Java IO](#java-io)
   * [Socket编程](#socket编程)
   * [客户端，服务端的线程模型](#客户端，服务端的线程模型)
@@ -14,16 +13,6 @@
     * [个人公众号：黄小斜](#个人公众号：黄小斜)
 
 
----
-title: Java网络编程与NIO学习总结
-date: 2018-07-08 22:08:22
-tags:
-	- Java网络编程
-	- NIO
-categories:
-	- 后端
-	- 技术总结
----
 这篇总结主要是基于我之前Java网络编程与NIO系列文章而形成的的。主要是把重要的知识点用自己的话说了一遍，可能会有一些错误，还望见谅和指点。谢谢
 
 更多详细内容可以查看我的专栏文章：Java网络编程与NIO
@@ -161,6 +150,7 @@ container是一个多级容器，最外层到最内层依次是engine，host，c
 
 下面是个server.xml文件实例，Tomcat根据该文件进行部署
 
+````
 <Server>                                                //顶层类元素，可以包括多个Service   
     <Service>                                           //顶层类元素，可包含一个Engine，多个Connecter
         <Connector>                                     //连接器类元素，代表通信接口
@@ -173,7 +163,7 @@ container是一个多级容器，最外层到最内层依次是engine，host，c
         </Connector>
     </Service>
 </Server>
-
+````
 
 根据配置文件初始化容器信息，当请求到达时进行容器间的请求传递，事实上整个链条被称作pipeline，pipeline连接了各个容器的入口，由于每个容器和组件都实现了lifecycle接口。
 

docs/java/network-programming/Java网络编程与NIO详解10：深度解读Tomcat中的NIO模型.md

@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [一、I/O复用模型解读](#一、io复用模型解读)
   * [二、TOMCAT对IO模型的支持](#二、tomcat对io模型的支持)
   * [三、TOMCAT中NIO的配置与使用](#三、tomcat中nio的配置与使用)
@@ -9,7 +8,6 @@
   * [七、关于性能](#七、关于性能)
   * [八、总结](#八、总结)
 
-
 本文转自：http://www.sohu.com/a/203838233_827544
 
 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看
@@ -37,8 +35,7 @@
 
 Tomcat的NIO是基于I/O复用来实现的。对这点一定要清楚，不然我们的讨论就不在一个逻辑线上。下面这张图学习过I/O模型知识的一般都见过，出自《UNIX网络编程》，I/O模型一共有阻塞式I/O，非阻塞式I/O，I/O复用(select/poll/epoll)，信号驱动式I/O和异步I/O。这篇文章讲的是I/O复用。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/0ab0b70be5a64b0e9014de867235da73.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104442.png)
 IO复用.png
 
 这里先来说下用户态和内核态，直白来讲，如果线程执行的是用户代码，当前线程处在用户态，如果线程执行的是内核里面的代码，当前线程处在内核态。更深层来讲，操作系统为代码所处的特权级别分了4个级别。
@@ -51,13 +48,12 @@ IO复用.png
 
 上面提到的网络事件有连接就绪，接收就绪，读就绪，写就绪四个网络事件。I/O复用主要是通过Selector复用器来实现的，可以结合下面这个图理解上面的叙述。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/3a18d371c9c848479ca39d8eb4e57ce4.jpeg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104504.png)
 Selector图解.png
 
 ## 二、TOMCAT对IO模型的支持
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/983c122c2a924e01b9f898279e2bd0b5.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104517.png)
 
 tomcat支持IO类型图.png
 
@@ -71,7 +67,7 @@ tomcat从6以后开始支持NIO模型，实现是基于JDK的java.nio包。这
 
 ## 四、NioEndpoint组件关系图解读
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/4e1a924a60974c76ab5115007562e563.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104543.png)
 
 tomcatnio组成.png
 
@@ -87,8 +83,7 @@ LimitLatch是连接控制器，它负责维护连接数的计算，nio模式下
 
 ## 五、NioEndpoint执行序列图
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/d69c2ef5110d4706aa7284c616d62927.jpeg)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104621.png)
 tomcatnio序列图.png
 
 在下一小节NioEndpoint源码解读中我们将对步骤1-步骤11依次找到对应的代码来说明。
@@ -99,8 +94,7 @@ tomcatnio序列图.png
 
 无论是BIO还是NIO，开始都会初始化连接限制，不可能无限增大，NIO模式下默认是10000。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/332338f6d2c8488e9b35cd4fd76f078a.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104637.png)
 **6.2、步骤解读**
 
 下面我们着重叙述跟NIO相关的流程，共分为11个步骤，分别对应上面序列图中的步骤。
@@ -111,46 +105,41 @@ tomcatnio序列图.png
 
 Socket，NIO下这里返回的是SocketChannel。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/ca01395590944a35b4717b15c984849e.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104855.png)
 **步骤2**：启动接收线程
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/e7c40dc6f84b48f4915ca854c2a3b2cc.png)
 
 **步骤3**：ServerSocketChannel.accept()接收新连接
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/50ddbfe042514ba29a8bcd606b125f76.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104937.png)
 
 **步骤4**：将接收到的链接通道设置为非阻塞
 
 **步骤5**：构造NioChannel对象
 
 **步骤6**：register注册到轮询线程
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/f3f5130bcf7a4348bc9752bd009c1b72.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405104957.png)
 
 **步骤7**：构造PollerEvent，并添加到事件队列
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/65de3c5cebea42c59ff19e8a168cf406.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105014.png)
 
 **步骤8**：启动轮询线程
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/5c097feaa2324a2da082a81287f9e862.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105027.png)
 
 **步骤9**：取出队列中新增的PollerEvent并注册到Selector
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/8ac5e80b9aa84f57b4c3f7ecd4e2ea1d.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105043.png)
 
 **步骤10**：Selector.select()
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/82d20de2a4614eab9fe14e58234db552.jpeg)
-
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/75641a4b8d444f8ab7a033bee9497c2b.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105057.png)
 
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105110.png)
 **步骤11**：根据选择的SelectionKey构造SocketProcessor提交到请求处理线程
-
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/b8ec9bbcbdcd4088841741acb20152f8.png)
-
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105154.png)
 **6.3、NioBlockingSelector和BlockPoller介绍**
 
 上面的序列图有个地方我没有描述，就是NioSelectorPool这个内部类，是因为在整体理解tomcat的nio上面在序列图里面不包括它更好理解。
@@ -159,13 +148,13 @@ Socket，NIO下这里返回的是SocketChannel。
 
 以执行servlet后，得到response，往socket中写数据为例，最终写的过程调用NioBlockingSelector的write方法。代码如下：
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/4ac6ac8fdb0a4b24bdcb646a09cbb13e.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105223.png)
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/549283c8059b4e3c8798077b654dc3d1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105237.png)
 
 也就是说当socket.write()返回0时，说明网络状态不稳定，这时将socket注册OP_WRITE事件到辅Selector，由BlockPoller线程不断轮询这个辅Selector，直到发现这个socket的写状态恢复了，通过那个倒数计数器，通知Worker线程继续写socket动作。看一下BlockSelector线程的代码逻辑：
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/626817ca25fc4a439dbf5d23c2c08d0e.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105251.png)
 
 使用这个辅Selector主要是减少线程间的切换，同时还可减轻主Selector的负担。
 
@@ -175,13 +164,9 @@ Socket，NIO下这里返回的是SocketChannel。
 
 NIO的优势更在于用少量的线程hold住大量的连接。还有一点，我们在压测的过程中，遇到在NIO模式下刚开始的一小段时间内容，会有错误，这是因为一般的压测工具是基于一种长连接，也就是说比如模拟1000并发，那么同时建立1000个连接，下一时刻再发送请求就是基于先前的这1000个连接来发送，还有TOMCAT的NIO处理是有POLLER线程来接管的，它的线程数一般等于CPU的核数，如果一瞬间有大量并发过来，POLLER也会顿时处理不过来。
 
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/7d62f8792e1c41f090d945c755bba6c7.jpeg)
-
-压测1.jpeg
-
-![](http://5b0988e595225.cdn.sohucs.com/images/20171112/e8ec450685d64e5785db44a0bb60660c.jpeg)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105304.png)
 
-压测2.jpeg
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105318.png)
 
 ## 八、总结
 

docs/java/network-programming/Java网络编程与NIO详解11：Tomcat中的Connector源码分析（NIO）.md

@@ -1,5 +1,4 @@
-# Table of Contents
-
+# 目录
   * [前言](#前言)
   * [源码环境准备](#源码环境准备)
   * [endpoint](#endpoint)
@@ -43,7 +42,7 @@
 
 先简单画一张图示意一下本文的主要内容：
 
-![0](https://www.javadoop.com/blogimages/tomcat-nio/0.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105401.png)
 
 **目录**
 
@@ -87,7 +86,7 @@ public static void main(String[] args) throws LifecycleException {
 
 这里，介绍第一个重要的概念：**Connector**。在 Tomcat 中，使用 Connector 来处理连接，一个 Tomcat 可以配置多个 Connector，分别用于监听不同端口，或处理不同协议。
 
-在 Connector 的构造方法中，我们可以传 `HTTP/1.1` 或 `AJP/1.3` 用于指定协议，也可以传入相应的协议处理类，毕竟协议不是重点，将不同端口进来的连接对应不同处理类才是正道。典型地，我们可以指定以下几个协议处理类：
+在 Connector 的构造方法中，我们可以传`HTTP/1.1`或`AJP/1.3`用于指定协议，也可以传入相应的协议处理类，毕竟协议不是重点，将不同端口进来的连接对应不同处理类才是正道。典型地，我们可以指定以下几个协议处理类：
 
 *   org.apache.coyote.http11.Http11NioProtocol：对应非阻塞 IO
 *   org.apache.coyote.http11.Http11Nio2Protocol：对应异步 IO
@@ -119,9 +118,9 @@ public static void main(String[] args) throws LifecycleException {
 
 ## endpoint
 
-前面我们说过一个 Connector 对应一个协议，当然这描述也不太对，NIO 和 NIO2 就都是处理 HTTP/1.1 的，只不过一个使用非阻塞，一个使用异步。进到指定 protocol 代码，我们就会发现，它们的代码及其简单，只不过是指定了特定的 **endpoint**。
+前面我们说过一个 Connector 对应一个协议，当然这描述也不太对，NIO 和 NIO2 就都是处理 HTTP/1.1 的，只不过一个使用非阻塞，一个使用异步。进到指定 protocol 代码，我们就会发现，它们的代码及其简单，只不过是指定了特定的**endpoint**。
 
-打开 `Http11NioProtocol` 和 `Http11Nio2Protocol`源码，我们可以看到，在构造方法中，它们分别指定了 NioEndpoint 和 Nio2Endpoint。
+打开`Http11NioProtocol`和`Http11Nio2Protocol`源码，我们可以看到，在构造方法中，它们分别指定了 NioEndpoint 和 Nio2Endpoint。
 
 ```
 // 非阻塞模式
@@ -143,15 +142,15 @@ public class Http11Nio2Protocol extends AbstractHttp11JsseProtocol<Nio2Channel>
 }
 ```
 
-这里介绍第二个重要的概念：**endpoint**。Tomcat 使用不同的 endpoint 来处理不同的协议请求，今天我们的重点是 **NioEndpoint**，其使用**非阻塞 IO** 来进行处理 HTTP/1.1 协议的请求。
+这里介绍第二个重要的概念：**endpoint**。Tomcat 使用不同的 endpoint 来处理不同的协议请求，今天我们的重点是**NioEndpoint**，其使用**非阻塞 IO**来进行处理 HTTP/1.1 协议的请求。
 
-**NioEndpoint** 继承 => **AbstractJsseEndpoint** 继承 => **AbstractEndpoint**。中间的 AbstractJsseEndpoint 主要是提供了一些关于 `HTTPS` 的方法，这块我们暂时忽略它，后面所有关于 HTTPS 的我们都直接忽略，感兴趣的读者请自行分析。
+**NioEndpoint**继承 =>**AbstractJsseEndpoint**继承 =>**AbstractEndpoint**。中间的 AbstractJsseEndpoint 主要是提供了一些关于`HTTPS`的方法，这块我们暂时忽略它，后面所有关于 HTTPS 的我们都直接忽略，感兴趣的读者请自行分析。
 
 ## init 过程分析
 
 下面，我们看看从 tomcat.start() 一直到 NioEndpoint 的过程。
 
-**1\. AbstractProtocol** # **init**
+**1\. AbstractProtocol**#**init**
 
 ```
 @Override
@@ -165,7 +164,7 @@ public void init() throws Exception {
 }
 ```
 
-**2\. AbstractEndpoint** # **init**
+**2\. AbstractEndpoint**#**init**
 
 ```
 public final void init() throws Exception {
@@ -177,7 +176,7 @@ public final void init() throws Exception {
 }
 ```
 
-**3\. NioEndpoint** # **bind**
+**3\. NioEndpoint**#**bind**
 
 这里就到我们的 NioEndpoint 了，要使用到我们之前学习的 NIO 的知识了。
 
@@ -321,9 +320,9 @@ public void startInternal() throws Exception {
 }
 ```
 
-到这里，我们启动了**工作线程池**、 **poller 线程组**、**acceptor 线程组**。同时，工作线程池初始就已经启动了 10 个线程。我们用 **jconsole** 来看看此时的线程，请看下图：
+到这里，我们启动了**工作线程池**、**poller 线程组**、**acceptor 线程组**。同时，工作线程池初始就已经启动了 10 个线程。我们用**jconsole**来看看此时的线程，请看下图：
 
-![1](https://www.javadoop.com/blogimages/tomcat-nio/1.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105500.png)
 
 从 jconsole 中，我们可以看到，此时启动了 BlockPoller、worker、poller、acceptor、AsyncTimeout，大家应该都已经清楚了每个线程是哪里启动的吧。
 
@@ -345,7 +344,7 @@ public Acceptor(AbstractEndpoint<?,U> endpoint) {
 }
 ```
 
-**threadName** 就是一个线程名字而已，Acceptor 的状态 **state** 主要是随着 endpoint 来的。
+**threadName**就是一个线程名字而已，Acceptor 的状态**state**主要是随着 endpoint 来的。
 
 ```
 public enum AcceptorState {
@@ -498,7 +497,7 @@ protected boolean setSocketOptions(SocketChannel socket) {
 }
 ```
 
-我们看到，这里又没有进行实际的处理，而是将这个 SocketChannel **注册**到了其中一个 poller 上。因为我们知道，acceptor 应该尽可能的简单，只做 accept 的工作，简单处理下就往后面扔。acceptor 还得回到之前的循环去 accept 新的连接呢。
+我们看到，这里又没有进行实际的处理，而是将这个 SocketChannel**注册**到了其中一个 poller 上。因为我们知道，acceptor 应该尽可能的简单，只做 accept 的工作，简单处理下就往后面扔。acceptor 还得回到之前的循环去 accept 新的连接呢。
 
 我们只需要明白，此时，往 poller 中注册了一个 NioChannel 实例，此实例包含客户端过来的 SocketChannel 和一个 SocketBufferHandler 实例。
 
@@ -820,7 +819,7 @@ protected SocketProcessorBase<NioChannel> createSocketProcessor(
 
 最后，再祭出文章开始的那张图来总结一下：
 
-![0](https://www.javadoop.com/blogimages/tomcat-nio/0.png)
+![](https://java-tutorial.oss-cn-shanghai.aliyuncs.com/20230405105530.png)
 
 这里简单梳理下前面我们说的流程，帮大家回忆一下：