前言

在網絡的初期，網民很少，服務器完全沒有壓力，通常用一個線程追蹤處理一個請求。

其實代碼實現大家都知道，就是服務器上有個ServerSocket在某個端口監(jiān)聽，接收到客戶端的連接后，會創(chuàng)建一個Socket，并把它交給一個線程進行后續(xù)處理。

線程主要從Socket讀取客戶端傳過來的數據，然后進行業(yè)務處理，并把結果再寫入Socket傳回客戶端。

由于網絡的原因，Socket創(chuàng)建后并不一定能立刻從它上面讀取數據，可能需要等一段時間，此時線程也必須一直阻塞著。在向Socket寫入數據時，也可能會使線程阻塞。

一個小示例

客戶端：創(chuàng)建20個Socket并連接到服務器上，再創(chuàng)建20個線程，每個線程負責一個Socket。

服務器端：接收到這20個連接，創(chuàng)建20個Socket，接著創(chuàng)建20個線程，每個線程負責一個Socket。

為了模擬服務器端的Socket在創(chuàng)建后不能立馬讀取數據，讓客戶端的20個線程分別休眠5-10之間的一個隨機秒數。

客戶端的20個線程會在第5秒到第10秒這段時間內陸陸續(xù)續(xù)的向服務器端發(fā)送數據，服務器端的20個線程也會陸陸續(xù)續(xù)接收到數據。

public class BioServer {static AtomicInteger counter = new AtomicInteger(0);static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss"); public static void main(String[] args) {try {ServerSocket ss = new ServerSocket();ss.bind(new InetSocketAddress("localhost", 8080));while (true) {Socket s = ss.accept();processWithNewThread(s);}} catch (Exception e) {e.printStackTrace();}}static void processWithNewThread(Socket s) {Runnable run = () -> {InetSocketAddress rsa = (InetSocketAddress)s.getRemoteSocketAddress();System.out.println(time() + "->" + rsa.getHostName() + ":" + rsa.getPort() + "->" + Thread.currentThread().getId() + ":" + counter.incrementAndGet());try {String result = readBytes(s.getInputStream());System.out.println(time() + "->" + result + "->" + Thread.currentThread().getId() + ":" + counter.getAndDecrement());s.close();} catch (Exception e) {e.printStackTrace();}};new Thread(run).start();}static String readBytes(InputStream is) throws Exception {long start = 0;int total = 0;int count = 0;byte[] bytes = new byte[1024];//開始讀數據的時間long begin = System.currentTimeMillis();while ((count = is.read(bytes)) > -1) {if (start < 1) {//第一次讀到數據的時間start = System.currentTimeMillis();}total += count;}//讀完數據的時間long end = System.currentTimeMillis();return "wait=" + (start - begin) + "ms,read=" + (end - start) + "ms,total=" + total + "bs";}static String time() {return sdf.format(new Date());} } public class Client {public static void main(String[] args) {try {for (int i = 0; i < 20; i++) {Socket s = new Socket();s.connect(new InetSocketAddress("localhost", 8080));processWithNewThread(s, i);}} catch (IOException e) {e.printStackTrace();}}static void processWithNewThread(Socket s, int i) {Runnable run = () -> {try {//睡眠隨機的5-10秒，模擬數據尚未就緒Thread.sleep((new Random().nextInt(6) + 5) * 1000);//寫1M數據，為了拉長服務器端讀數據的過程s.getOutputStream().write(prepareBytes());//睡眠1秒，讓服務器端把數據讀完Thread.sleep(1000);s.close();} catch (Exception e) {e.printStackTrace();}};new Thread(run).start();}static byte[] prepareBytes() {byte[] bytes = new byte[1024*1024*1];for (int i = 0; i < bytes.length; i++) {bytes[i] = 1;}return bytes;} } 時間->IP:Port->線程Id:當前線程數 15:11:52->127.0.0.1:55201->10:1 15:11:52->127.0.0.1:55203->12:2 15:11:52->127.0.0.1:55204->13:3 15:11:52->127.0.0.1:55207->16:4 15:11:52->127.0.0.1:55208->17:5 15:11:52->127.0.0.1:55202->11:6 15:11:52->127.0.0.1:55205->14:7 15:11:52->127.0.0.1:55206->15:8 15:11:52->127.0.0.1:55209->18:9 15:11:52->127.0.0.1:55210->19:10 15:11:52->127.0.0.1:55213->22:11 15:11:52->127.0.0.1:55214->23:12 15:11:52->127.0.0.1:55217->26:13 15:11:52->127.0.0.1:55211->20:14 15:11:52->127.0.0.1:55218->27:15 15:11:52->127.0.0.1:55212->21:16 15:11:52->127.0.0.1:55215->24:17 15:11:52->127.0.0.1:55216->25:18 15:11:52->127.0.0.1:55219->28:19 15:11:52->127.0.0.1:55220->29:20時間->等待數據的時間,讀取數據的時間,總共讀取的字節(jié)數->線程Id:當前線程數 15:11:58->wait=5012ms,read=1022ms,total=1048576bs->17:20 15:11:58->wait=5021ms,read=1022ms,total=1048576bs->13:19 15:11:58->wait=5034ms,read=1008ms,total=1048576bs->11:18 15:11:58->wait=5046ms,read=1003ms,total=1048576bs->12:17 15:11:58->wait=5038ms,read=1005ms,total=1048576bs->23:16 15:11:58->wait=5037ms,read=1010ms,total=1048576bs->22:15 15:11:59->wait=6001ms,read=1017ms,total=1048576bs->15:14 15:11:59->wait=6016ms,read=1013ms,total=1048576bs->27:13 15:11:59->wait=6011ms,read=1018ms,total=1048576bs->24:12 15:12:00->wait=7005ms,read=1008ms,total=1048576bs->20:11 15:12:00->wait=6999ms,read=1020ms,total=1048576bs->14:10 15:12:00->wait=7019ms,read=1007ms,total=1048576bs->26:9 15:12:00->wait=7012ms,read=1015ms,total=1048576bs->21:8 15:12:00->wait=7023ms,read=1008ms,total=1048576bs->25:7 15:12:01->wait=7999ms,read=1011ms,total=1048576bs->18:6 15:12:02->wait=9026ms,read=1014ms,total=1048576bs->10:5 15:12:02->wait=9005ms,read=1031ms,total=1048576bs->19:4 15:12:03->wait=10007ms,read=1011ms,total=1048576bs->16:3 15:12:03->wait=10006ms,read=1017ms,total=1048576bs->29:2 15:12:03->wait=10010ms,read=1022ms,total=1048576bs->28:1

從列子得出心得

可以看到服務器端確實為每個連接創(chuàng)建一個線程，共創(chuàng)建了20個線程。

客戶端進入休眠約5-10秒，模擬連接上數據不就緒，服務器端線程在等待，等待時間約5-10秒。

客戶端陸續(xù)結束休眠，往連接上寫入1M數據，服務器端開始讀取數據，整個讀取過程約1秒。

可以看到，服務器端的工作線程會把時間花在“等待數據”和“讀取數據”這兩個過程上。

有兩個不好的點

一是有很多客戶端同時發(fā)起請求的話，服務器端要創(chuàng)建很多的線程，可能會因為超過了上限而造成崩潰。
二是每個線程的大部分時光中都是在阻塞著，無事可干，造成極大的資源浪費。

開頭已經說了那個年代網民很少，所以，不可能會有大量請求同時過來。至于資源浪費就浪費吧，反正閑著也是閑著。

再來個簡單的小例子

飯店共有10張桌子，且配備了10位服務員。只要有客人來了，大堂經理就把客人帶到一張桌子，并安排一位服務員全程陪同。

即使客人暫時不需要服務，服務員也一直在旁邊站著。可能覺著是一種浪費，其實非也，這就是尊貴的VIP服務。

其實，VIP映射的是一對一的模型，主要體現在“專用”上或“私有”上。

真正的多路復用技術

又可以舉個小列子

一條小水渠里水在流，在一端往里倒入大量乒乓球，在另一端用網進行過濾，把乒乓球和水流分開。

這就是一個比較“土”的多路復用，首先在發(fā)射端把多種信號或數據進行“混合”，接著是在通道上進行傳輸，最后在接收端“分離”出自己需要的信號或數據。

相信大家都看出來了，這里的重點其實就是處理好“混合”和“分離”，對于不同的信號或數據，有不同的處理方法。

比如以前的有線電視是模擬信號，即電磁波。一家一般只有一根信號線，但可以同時接多個電視，每個電視任意換臺，互不影響。

這是由于不同頻率的波可以混合和分離。（當然，可能不是十分準確，明白意思就行了。）

再比如城市的高鐵站一般都有數個站臺供高鐵（同時）停靠，但城市間的高鐵軌道單方向只有一條，如何保證那么多趟高鐵安全運行呢？

很明顯是分時使用，每趟高鐵都有自己的時刻。多趟高鐵按不同的時刻出站相當于混合，按不同的時刻進站相當于分離。

總結一下，多路指的是多種不同的信號或數據或其它事物，復用指的是共用同一個物理鏈路或通道或載體。

您先看著，我一會再過來

一對一服務是典型的有錢任性，雖然響應及時、服務周到，但不是每個人都能享受的，畢竟還是“屌絲”多嘛，那就來個共享服務吧。

所以實際當中更多的情況是，客人坐下后，會給他一個菜單，讓他先看著，反正也不可能立馬點餐，服務員就去忙別的了。

可能不時的會有服務員從客人身旁經過，發(fā)現客人還沒有點餐，就會主動去詢問現在需要點餐嗎？

如果需要，服務員就給你寫菜單，如果不需要，服務員就繼續(xù)往前走了。

這種情況飯店整體運行的也很好，但是服務員人數少多了。現在服務10桌客人，4個服務員綽綽有余。（這節(jié)省的可都是純利潤呀。)

因為10桌客人同時需要服務的情況幾乎是不會發(fā)生的，絕大部分情況都是錯開的。如果真有的話，那就等會好了，又不是120/119，人命關天的。

回到代碼里，情況與之非常相似，完全可以采用相同的理論去處理。

連接建立后，找個地方把它放到那里，可以暫時先不管它，反正此時也沒有數據可讀。

但是數據早晚會到來的，所以，要不時的去詢問每個連接有數據沒有，有的話就讀取數據，沒有的話就繼續(xù)不管它。

其實這個模式在Java里早就有了，就是Java NIO，這里的大寫字母“N”是單詞“New”，即“新”的意思，主要是為了和上面的“一對一”進行區(qū)分。

先鋪墊一下吧

現在需要把Socket交互的過程再稍微細化一些。客戶端先請求連接，connect，服務器端然后接受連接，accept，然后客戶端再向連接寫入數據，write，接著服務器端從連接上讀出數據，read。

和打電話的場景一樣，主叫撥號，connect，被叫接聽，accept，主叫說話，speak，被叫聆聽，listen。主叫給被叫打電話，說明主叫找被叫有事，所以被叫關注的是接通電話，聽對方說。

客戶端主動向服務器端發(fā)起請求，說明客戶端找服務器端有事，所以服務器端關注的是接受請求，讀取對方傳來的數據。這里把接受請求，讀取數據稱為服務器端感興趣的操作。

在Java NIO中，接受請求的操作，用OP_ACCEPT表示，讀取數據的操作，用OP_READ表示。

我決定先過一遍飯店的場景，讓首次接觸Java NIO的同學不那么迷茫。就是把常規(guī)的場景進行了定向整理，稍微有點刻意，明白意思就行了。

1、專門設立一個“跑腿”服務員，工作職責單一，就是問問客人是否需要服務。

2、站在門口接待客人，本來是大堂經理的工作，但是他不愿意在門口盯著，于是就委托給跑腿服務員，你幫我盯著，有人來了告訴我。

于是跑腿服務員就有了一個任務，替大堂經理盯梢。終于來客人了，跑腿服務員趕緊告訴了大堂經理。

3、大堂經理把客人帶到座位上，對跑腿服務員說，客人接下來肯定是要點餐的，但是現在在看菜單，不知道什么時候能看好，所以你不時的過來問問，看需不需要點餐，需要的話就再喊來一個“點餐”服務員給客人寫菜單。

于是跑腿服務員就又多了一個任務，就是盯著這桌客人，不時來問問，如果需要服務的話，就叫點餐服務員過來服務。

4、跑腿服務員在某次詢問中，客人終于決定點餐了，跑題服務員趕緊找來一個點餐服務員為客人寫菜單。

5、就這樣，跑腿服務員既要盯著門外新過來的客人，也要盯著門內已經就坐的客人。新客人來了，通知大堂經理去接待。就坐的客人決定點餐了，通知點餐服務員去寫菜單。

事情就這樣一直循環(huán)的持續(xù)下去，一切，都挺好。角色明確，職責單一，配合很好。

大堂經理和點餐服務員是需求的提供者或實現者，跑腿服務員是需求的發(fā)現者，并識別出需求的種類，需要接待的交給大堂經理，需要點餐的交給點餐服務員。

哈哈，Java NIO來啦

代碼的寫法非常的固定，可以配合著后面的解說來看，這樣就好理解了，如下：

public class NioServer {static int clientCount = 0;static AtomicInteger counter = new AtomicInteger(0);static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss"); public static void main(String[] args) {try {Selector selector = Selector.open();ServerSocketChannel ssc = ServerSocketChannel.open();ssc.configureBlocking(false);ssc.register(selector, SelectionKey.OP_ACCEPT);ssc.bind(new InetSocketAddress("localhost", 8080));while (true) {selector.select();Set<SelectionKey> keys = selector.selectedKeys();Iterator<SelectionKey> iterator = keys.iterator();while (iterator.hasNext()) {SelectionKey key = iterator.next();iterator.remove();if (key.isAcceptable()) {ServerSocketChannel ssc1 = (ServerSocketChannel)key.channel();SocketChannel sc = null;while ((sc = ssc1.accept()) != null) {sc.configureBlocking(false);sc.register(selector, SelectionKey.OP_READ);InetSocketAddress rsa = (InetSocketAddress)sc.socket().getRemoteSocketAddress();System.out.println(time() + "->" + rsa.getHostName() + ":" + rsa.getPort() + "->" + Thread.currentThread().getId() + ":" + (++clientCount));}} else if (key.isReadable()) {//先將“讀”從感興趣操作移出，待把數據從通道中讀完后，再把“讀”添加到感興趣操作中//否則，該通道會一直被選出來key.interestOps(key.interestOps() & (~ SelectionKey.OP_READ));processWithNewThread((SocketChannel)key.channel(), key);}}}} catch (Exception e) {e.printStackTrace();}}static void processWithNewThread(SocketChannel sc, SelectionKey key) {Runnable run = () -> {counter.incrementAndGet();try {String result = readBytes(sc);//把“讀”加進去key.interestOps(key.interestOps() | SelectionKey.OP_READ);System.out.println(time() + "->" + result + "->" + Thread.currentThread().getId() + ":" + counter.get());sc.close();} catch (Exception e) {e.printStackTrace();}counter.decrementAndGet();};new Thread(run).start();}static String readBytes(SocketChannel sc) throws Exception {long start = 0;int total = 0;int count = 0;ByteBuffer bb = ByteBuffer.allocate(1024);//開始讀數據的時間long begin = System.currentTimeMillis();while ((count = sc.read(bb)) > -1) {if (start < 1) {//第一次讀到數據的時間start = System.currentTimeMillis();}total += count;bb.clear();}//讀完數據的時間long end = System.currentTimeMillis();return "wait=" + (start - begin) + "ms,read=" + (end - start) + "ms,total=" + total + "bs";}static String time() {return sdf.format(new Date());} }

它的大致處理過程如下：
1、定義一個選擇器，Selector。

相當于設立一個跑腿服務員。

2、定義一個服務器端套接字通道，ServerSocketChannel，并配置為非阻塞的。

相等于聘請了一位大堂經理。

3、將套接字通道注冊到選擇器上，并把感興趣的操作設置為OP_ACCEPT。

相當于大堂經理給跑腿服務員說，幫我盯著門外，有客人來了告訴我。

4、進入死循環(huán)，選擇器不時的進行選擇。

相當于跑腿服務員一遍又一遍的去詢問、去轉悠。

5、選擇器終于選擇出了通道，發(fā)現通道是需要Acceptable的。

相當于跑腿服務員終于發(fā)現門外來客人了，客人是需要接待的。

6、于是服務器端套接字接受了這個通道，開始處理。

相當于跑腿服務員把大堂經理叫來了，大堂經理開始著手接待。

7、把新接受的通道配置為非阻塞的，并把它也注冊到了選擇器上，該通道感興趣的操作為OP_READ。

相當于大堂經理把客人帶到座位上，給了客人菜單，并又把客人委托給跑腿服務員，說客人接下來肯定是要點餐的，你不時的來問問。

8、選擇器繼續(xù)不時的進行選擇著。

相當于跑腿服務員繼續(xù)不時的詢問著、轉悠著。

9、選擇器終于又選擇出了通道，這次發(fā)現通道是需要Readable的。

相當于跑腿服務員終于發(fā)現了一桌客人有了需求，是需要點餐的。

10、把這個通道交給了一個新的工作線程去處理。

相當于跑腿服務員叫來了點餐服務員，點餐服務員開始為客人寫菜單。

11、這個工作線程處理完后，就被回收了，可以再去處理其它通道。

相當于點餐服務員寫好菜單后，就走了，可以再去為其他客人寫菜單。

12、選擇器繼續(xù)著重復的選擇工作，不知道什么時候是個頭。

相當于跑腿服務員繼續(xù)著重復的詢問、轉悠，不知道未來在何方。

相信你已經看出來了，大堂經理相當于服務器端套接字，跑腿服務員相當于選擇器，點餐服務員相當于Worker線程。

參考

參考

總結

以上是生活随笔為你收集整理的20200321——IO 多路复用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。