深度解讀Tomcat中的NIO模型
1、I/O複用模型解讀
Tomcat的NIO是基於I/O複用來實現的。對這點必定要清楚，否則咱們的討論就不在一個邏輯線上。下面這張圖學習過I/O模型知識的通常都見過，出自《UNIX網絡編程》，I/O模型一共有阻塞式I/O，非阻塞式I/O，I/O複用(select/poll/epoll)，信號驅動式I/O和異步I/O。這篇文章講的是I/O複用。html
IO複用.pngjava
這裏先來講下用戶態和內核態，直白來說，若是線程執行的是用戶代碼，當前線程處在用戶態，若是線程執行的是內核裏面的代碼，當前線程處在內核態。更深層來說，操做系統爲代碼所處的特權級別分了4個級別。不過現代操做系統只用到了0和3兩個級別。0和3的切換就是用戶態和內核態的切換。更詳細的可參照《深刻理解計算機操做系統》。I/O複用模型，是同步非阻塞，這裏的非阻塞是指I/O讀寫，對應的是recvfrom操做，由於數據報文已經準備好，無需阻塞。說它是同步，是由於，這個執行是在一個線程裏面執行的。有時候，還會說它又是阻塞的，其實是指阻塞在select上面，必須等到讀就緒、寫就緒等網絡事件。有時候咱們又說I/O複用是多路複用，這裏的多路是指N個鏈接，每個鏈接對應一個channel，或者說多路就是多個channel。複用，是指多個鏈接複用了一個線程或者少許線程(在Tomcat中是Math.min(2,Runtime.getRuntime().availableProcessors()))。web
上面提到的網絡事件有鏈接就緒，接收就緒，讀就緒，寫就緒四個網絡事件。I/O複用主要是經過Selector複用器來實現的，能夠結合下面這個圖理解上面的敘述。apache
Selector圖解.png編程
2、TOMCAT對IO模型的支持
tomcat支持IO類型圖.pngtomcat
tomcat從6之後開始支持NIO模型，實現是基於JDK的java.nio包。這裏能夠看到對read body 和response body是Blocking的。關於這點在第6.3節源代碼閱讀有重點介紹。服務器
3、TOMCAT中NIO的配置與使用
在Connector節點配置protocol="org.apache.coyote.http11.Http11NioProtocol"，Http11NioProtocol協議下默認最大鏈接數是10000，也能夠從新修改maxConnections的值，同時咱們能夠設置最大線程數maxThreads，這裏設置的最大線程數就是Excutor的線程池的大小。在BIO模式下其實是沒有maxConnections，即便配置也不會生效，BIO模式下的maxConnections是保持跟maxThreads大小一致，由於它是一請求一線程模式。網絡
4、NioEndpoint組件關係圖解讀
tomcatnio組成.png併發
咱們要理解tomcat的nio最主要就是對NioEndpoint的理解。它一共包含LimitLatch、Acceptor、Poller、SocketProcessor、Excutor5個部分。LimitLatch是鏈接控制器，它負責維護鏈接數的計算，nio模式下默認是10000，達到這個閾值後，就會拒絕鏈接請求。Acceptor負責接收鏈接，默認是1個線程來執行，將請求的事件註冊到事件列表。有Poller來負責輪詢，Poller線程數量是cpu的核數Math.min(2,Runtime.getRuntime().availableProcessors())。由Poller將就緒的事件生成SocketProcessor同時交給Excutor去執行。Excutor線程池的大小就是咱們在Connector節點配置的maxThreads的值。在Excutor的線程中，會完成從socket中讀取http request，解析成HttpServletRequest對象，分派到相應的servlet並完成邏輯，而後將response經過socket發回client。在從socket中讀數據和往socket中寫數據的過程，並無像典型的非阻塞的NIO的那樣，註冊OP_READ或OP_WRITE事件到主Selector，而是直接經過socket完成讀寫，這時是阻塞完成的，可是在timeout控制上，使用了NIO的Selector機制，可是這個Selector並非Poller線程維護的主Selector，而是BlockPoller線程中維護的Selector，稱之爲輔Selector。詳細源代碼能夠參照 第6.3節。異步
5、NioEndpoint執行序列圖
tomcatnio序列圖.png
在下一小節NioEndpoint源碼解讀中咱們將對步驟1-步驟11依次找到對應的代碼來講明。
6、NioEndpoint源碼解讀
6.一、初始化
不管是BIO仍是NIO，開始都會初始化鏈接限制，不可能無限增大，NIO模式下默認是10000。
public void startInternal() throws Exception {
if (!running) {
//省略代碼...
initializeConnectionLatch();
//省略代碼...
}
}
protected LimitLatch initializeConnectionLatch() {
if (maxConnections==-1) return null;
if (connectionLimitLatch==null) {
connectionLimitLatch = new LimitLatch(getMaxConnections());
}
return connectionLimitLatch;
}
6.二、步驟解讀
下面咱們着重敘述跟NIO相關的流程，共分爲11個步驟，分別對應上面序列圖中的步驟。
步驟1：綁定IP地址及端口，將ServerSocketChannel設置爲阻塞。
這裏爲何要設置成阻塞呢，咱們一直都在說非阻塞。Tomcat的設計初衷主要是爲了操做方便。這樣這裏就跟BIO模式下同樣了。只不過在BIO下這裏返回的是Socket，NIO下這裏返回的是SocketChannel。
public void bind() throws Exception {
//省略代碼...
serverSock.socket().bind(addr,getBacklog());
serverSock.configureBlocking(true);
//省略代碼...
selectorPool.open();
}
步驟2：啓動接收線程
public void startInternal() throws Exception {
if (!running) {
//省略代碼...
startAcceptorThreads();
}
}
//這個方法實際是在它的超類AbstractEndpoint裏面
protected final void startAcceptorThreads() {
int count = getAcceptorThreadCount();
acceptors = new Acceptor[count];
for (int i = 0; i < count; i++) {
acceptors[i] = createAcceptor();
Thread t = new Thread(acceptors[i], getName() + "-Acceptor-" + i);
t.setPriority(getAcceptorThreadPriority());
t.setDaemon(getDaemon());
t.start();
}
}
步驟3：ServerSocketChannel.accept()接收新鏈接
protected class Acceptor extends AbstractEndpoint.Acceptor {
@Override
public void run() {
while (running) {
try {
//省略代碼...
SocketChannel socket = null;
try {
socket = serverSock.accept();//接收新鏈接
} catch (IOException ioe) {
//省略代碼...
throw ioe;
}
//省略代碼...
if (running && !paused) {
if (!setSocketOptions(socket)) {
//省略代碼...
}
} else {
//省略代碼...
}
} catch (SocketTimeoutException sx) {
} catch (IOException x) {
//省略代碼...
} catch (OutOfMemoryError oom) {
//省略代碼...
} catch (Throwable t) {
//省略代碼...
}
}
}
}
步驟4：將接收到的連接通道設置爲非阻塞
步驟5：構造NioChannel對象
步驟6：register註冊到輪詢線程
protected boolean setSocketOptions(SocketChannel socket) {
try {
socket.configureBlocking(false);//將鏈接通道設置爲非阻塞
Socket sock = socket.socket();
socketProperties.setProperties(sock);
NioChannel channel = nioChannels.poll();//構造NioChannel對象
//省略代碼...
getPoller0().register(channel);//register註冊到輪詢線程
} catch (Throwable t) {
//省略代碼...
}
//省略代碼...
}
步驟7：構造PollerEvent，並添加到事件隊列
protected ConcurrentLinkedQueue<Runnable> events = new ConcurrentLinkedQueue<Runnable>();
public void register(final NioChannel socket)
{
//省略代碼...
PollerEvent r = eventCache.poll();
//省略代碼...
addEvent(r);
}
步驟8：啓動輪詢線程
public void startInternal() throws Exception {
if (!running) {
//省略代碼...
// Start poller threads
pollers = new Poller[getPollerThreadCount()];
for (int i=0; i<pollers.length; i++) {
pollers[i] = new Poller();
Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i);
pollerThread.setPriority(threadPriority);
pollerThread.setDaemon(true);
pollerThread.start();
}
//省略代碼...
}
}
步驟9：取出隊列中新增的PollerEvent並註冊到Selector
public static class PollerEvent implements Runnable {
//省略代碼...
@Override
public void run() {
if ( interestOps == OP_REGISTER ) {
try {
socket.getIOChannel().register(socket.getPoller().getSelector(), SelectionKey.OP_READ, key);
} catch (Exception x) {
log.error("", x);
}
} else {
//省略代碼...
}//end if
}//run
//省略代碼...
}
步驟10：Selector.select()
public void run() {
// Loop until destroy() is called
while (true) {
try {
//省略代碼...
try {
if ( !close ) {
if (wakeupCounter.getAndSet(-1) > 0) {
keyCount = selector.selectNow();
} else {
keyCount = selector.select(selectorTimeout);
}
//省略代碼...
}
//省略代碼...
} catch ( NullPointerException x ) {
//省略代碼...
} catch ( CancelledKeyException x ) {
//省略代碼...
} catch (Throwable x) {
//省略代碼...
}
//省略代碼...
Iterator<SelectionKey> iterator =
keyCount > 0 ? selector.selectedKeys().iterator() : null;
while (iterator != null && iterator.hasNext()) {
SelectionKey sk = iterator.next();
KeyAttachment attachment = (KeyAttachment)sk.attachment();
if (attachment == null) {
iterator.remove();
} else {
attachment.access();
iterator.remove();
processKey(sk, attachment);//此方法跟下去就是把SocketProcessor交給Excutor去執行
}
}//while
//省略代碼...
} catch (OutOfMemoryError oom) {
//省略代碼...
}
}//while
//省略代碼...
}
步驟11：根據選擇的SelectionKey構造SocketProcessor提交到請求處理線程
public boolean processSocket(NioChannel socket, SocketStatus status, boolean dispatch) {
try {
//省略代碼...
SocketProcessor sc = processorCache.poll();
if ( sc == null ) sc = new SocketProcessor(socket,status);
else sc.reset(socket,status);
if ( dispatch && getExecutor()!=null ) getExecutor().execute(sc);
else sc.run();
} catch (RejectedExecutionException rx) {
//省略代碼...
} catch (Throwable t) {
//省略代碼...
}
//省略代碼...
}
6.三、NioBlockingSelector和BlockPoller介紹
上面的序列圖有個地方我沒有描述，就是NioSelectorPool這個內部類，是由於在總體理解tomcat的nio上面在序列圖裏面不包括它更好理解。在有了上面的基礎後，咱們在來講下NioSelectorPool這個類，對更深層瞭解Tomcat的NIO必定要知道它的做用。NioEndpoint對象中維護了一個NioSelecPool對象，這個NioSelectorPool中又維護了一個BlockPoller線程，這個線程就是基於輔Selector進行NIO的邏輯。以執行servlet後，獲得response，往socket中寫數據爲例，最終寫的過程調用NioBlockingSelector的write方法。代碼以下：
public int write(ByteBuffer buf, NioChannel socket, long writeTimeout,MutableInteger lastWrite) throws IOException {
SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
if ( key == null ) throw new IOException("Key no longer registered");
KeyAttachment att = (KeyAttachment) key.attachment();
int written = 0;
boolean timedout = false;
int keycount = 1; //assume we can write
long time = System.currentTimeMillis(); //start the timeout timer
try {
while ( (!timedout) && buf.hasRemaining()) {
if (keycount > 0) { //only write if we were registered for a write
//直接往socket中寫數據
int cnt = socket.write(buf); //write the data
lastWrite.set(cnt);
if (cnt == -1)
throw new EOFException();
written += cnt;
//寫數據成功，直接進入下一次循環，繼續寫
if (cnt > 0) {
time = System.currentTimeMillis(); //reset our timeout timer
continue; //we successfully wrote, try again without a selector
}
}
//若是寫數據返回值cnt等於0，一般是網絡不穩定形成的寫數據失敗
try {
//開始一個倒數計數器
if ( att.getWriteLatch()==null || att.getWriteLatch().getCount()==0) att.startWriteLatch(1);
//將socket註冊到輔Selector，這裏poller就是BlockSelector線程
poller.add(att,SelectionKey.OP_WRITE);
//阻塞，直至超時時間喚醒，或者在尚未達到超時時間，在BlockSelector中喚醒
att.awaitWriteLatch(writeTimeout,TimeUnit.MILLISECONDS);
}catch (InterruptedException ignore) {
Thread.interrupted();
}
if ( att.getWriteLatch()!=null && att.getWriteLatch().getCount()> 0) {
keycount = 0;
}else {
//還沒超時就喚醒，說明網絡狀態恢復，繼續下一次循環，完成寫socket
keycount = 1;
att.resetWriteLatch();
}
if (writeTimeout > 0 && (keycount == 0))
timedout = (System.currentTimeMillis() - time) >= writeTimeout;
} //while
if (timedout)
throw new SocketTimeoutException();
} finally {
poller.remove(att,SelectionKey.OP_WRITE);
if (timedout && key != null) {
poller.cancelKey(socket, key);
}
}
return written;
}
也就是說當socket.write()返回0時，說明網絡狀態不穩定，這時將socket註冊OP_WRITE事件到輔Selector，由BlockPoller線程不斷輪詢這個輔Selector，直到發現這個socket的寫狀態恢復了，經過那個倒數計數器，通知Worker線程繼續寫socket動做。看一下BlockSelector線程的代碼邏輯：
public void run() {
while (run) {
try {
......
Iterator iterator = keyCount > 0 ? selector.selectedKeys().iterator() : null;
while (run && iterator != null && iterator.hasNext()) {
SelectionKey sk = (SelectionKey) iterator.next();
KeyAttachment attachment = (KeyAttachment)sk.attachment();
try {
attachment.access();
iterator.remove(); ;
sk.interestOps(sk.interestOps() & (~sk.readyOps()));
if ( sk.isReadable() ) {
countDown(attachment.getReadLatch());
}
//發現socket可寫狀態恢復，將倒數計數器置位，通知Worker線程繼續
if (sk.isWritable()) {
countDown(attachment.getWriteLatch());
}
}catch (CancelledKeyException ckx) {
if (sk!=null) sk.cancel();
countDown(attachment.getReadLatch());
countDown(attachment.getWriteLatch());
}
}//while
}catch ( Throwable t ) {
log.error("",t);
}
}
events.clear();
try {
selector.selectNow();//cancel all remaining keys
}catch( Exception ignore ) {
if (log.isDebugEnabled())log.debug("",ignore);
}
}
使用這個輔Selector主要是減小線程間的切換，同時還可減輕主Selector的負擔。
7、關於性能
下面這份報告是咱們壓測的一個結果，跟想象的是否是不太同樣？幾乎沒有差異，實際上NIO優化的是I/O的讀寫，若是瓶頸不在這裏的話，好比傳輸字節數很小的狀況下，BIO和NIO其實是沒有差異的。NIO的優點更在於用少許的線程hold住大量的鏈接。還有一點，咱們在壓測的過程當中，遇到在NIO模式下剛開始的一小段時間內容，會有錯誤，這是由於通常的壓測工具是基於一種長鏈接，也就是說好比模擬1000併發，那麼同時創建1000個鏈接，下一時刻再發送請求就是基於先前的這1000個鏈接來發送，還有TOMCAT的NIO處理是有POLLER線程來接管的，它的線程數通常等於CPU的核數，若是一瞬間有大量併發過來，POLLER也會頓時處理不過來。
壓測1.jpeg
壓測2.jpeg
8、總結
NIO只是優化了網絡IO的讀寫，若是系統的瓶頸不在這裏，好比每次讀取的字節說都是500b，那麼BIO和NIO在性能上沒有區別。NIO模式是最大化壓榨CPU，把時間片都更好利用起來。對於操做系統來講，線程之間上下文切換的開銷很大，並且每一個線程都要佔用系統的一些資源如內存，有關線程資源可參照這篇文章《一臺java服務器能夠跑多少個線程》。所以，使用的線程越少越好。而I/O複用模型正是利用少許的線程來管理大量的鏈接。在對於維護大量長鏈接的應用裏面更適合用基於I/O複用模型NIO，好比web qq這樣的應用。因此咱們要清楚系統的瓶頸是I/O仍是CPU的計算。
轉載請註明做者及出處，並附上連接https://my.oschina.net/wangxindong/blog/1562957
參考資料：
http://tomcat.apache.org/tomcat-7.0-doc/config/http.html
http://gearever.iteye.com/blog/1844203 《Tomcat內核設計剖析》 《深刻理解計算機操做系統》 《UNIX網絡編程》卷1
- 1. 深度解讀 Tomcat 中的 NIO 模型
- 2. 深度解讀Tomcat中的NIO模型
- 3. Java網絡編程與NIO詳解10：深度解讀Tomcat中的NIO模型
- 4. 1.解讀Tomcat中的NIO模型
- 5. Transformer模型深度解讀
- 6. Tomcat NIO線程模型深刻分析
- 7. 【精讀】Transformer模型深度解讀
- 8. Java內存模型深度解讀
- 9. tomcat源碼解析——NIO線程模型
- 10. 模仿Tomcat的BIO,NIO線程模型
- 更多相關文章...
- • ASP.NET MVC - 模型 - ASP.NET 教程
- • Docker 安裝 Tomcat - Docker教程
- • 算法總結-深度優先算法
- • JDK13 GA發佈：5大特性解讀
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven