2. 程式人生 > >NIO實現TCP的非阻塞通訊

NIO實現TCP的非阻塞通訊

阿新 • • 發佈：2018-12-30

這一次寫NIO實現非阻塞通訊時遇到了很多問題，我所理解的非阻塞是對於一個使用者而言它的讀寫不會相互制約，而在此次編寫過程中，發現其實非阻塞是相對於多個使用者而言的。
看到網上一個對同步非同步阻塞非阻塞的例子，感覺挺好的，就拷過來了：

老張愛喝茶，廢話不說，煮開水。
出場人物：老張，水壺兩把（普通水壺，簡稱水壺；會響的水壺，簡稱響水壺）。
1 老張把水壺放到火上，立等水開。（同步阻塞）
老張覺得自己有點傻
2 老張把水壺放到火上，去客廳看電視，時不時去廚房看看水開沒有。（同步非阻塞）
老張還是覺得自己有點傻，於是變高端了，買了把會響笛的那種水壺。水開之後，能大聲發出嘀~~~~的噪音。
3
 
 老張把響水壺放到火上，立等水開。（非同步阻塞）
老張覺得這樣傻等意義不大
4 老張把響水壺放到火上，去客廳看電視，水壺響之前不再去看它了，響了再去拿壺。（非同步非阻塞）
老張覺得自己聰明瞭。


所謂同步非同步，只是對於水壺而言。
普通水壺，同步；響水壺，非同步。
雖然都能幹活，但響水壺可以在自己完工之後，提示老張水開了。這是普通水壺所不能及的。
同步只能讓呼叫者去輪詢自己（情況2中），造成老張效率的低下。

所謂阻塞非阻塞，僅僅對於老張而言。
立等的老張，阻塞；看電視的老張，非阻塞。
情況1和情況3中老張就是阻塞的，媳婦喊他都不知道。雖然3中響水壺是非同步的，可對於立等的老張沒有太大的意義。所以一般非同步是配合非阻塞使用的，這樣才能發揮非同步的效用。

——來源網路，作者不明。 

作者：愚抄
連結：https://www.zhihu
 
.com/question/19732473/answer/23434554
來源：知乎
著作權歸作者所有，轉載請聯絡作者獲得授權。

使用的類：
1.ServerSocketChannel類：ServerSocket的代替類，支援非阻塞通訊；
2.SocketChannel類：Socket的代替類，支援非阻塞通訊；
3.Selector：為ServerSocketChannel監控接收連線就緒事件，為SocketChannel監控連線就緒，讀就緒和寫就緒事件。
4.SelectionKey：代表ServerSocketChannel和SocketChannel向Selector註冊事件的控制代碼。

基本思路：
伺服器端：
1.使用ServerSocketChannel類對地址埠號進行繫結，通過open()方法獲取通道，並且設定為非阻塞；
2.通過Selector的open()方法，建立Selector物件；
3.進行註冊連線就緒事件；
3.通過Selector的select()方法返回註冊事件的數目，返回物件為SelectionKey，對SelectionKey進行遍歷，當監聽到連線事件的時候，就使用accept()連線並返回一個SocketChannel物件，對它註冊讀就緒事件；
4.收到訊息之後進行反饋；
客戶端：
1.通過IP和埠號進行連線；
2.通過Selector的open()方法建立該類物件；
3.進行註冊讀事件監聽，讀取伺服器端的反饋；
4.輸出訊息；

程式碼：
伺服器端：

package sency.lay.two;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

/**
 * 伺服器端
 * 
 * @author sency
 * 
 */
public class NServer {
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;
    private int port = 8000;
    // 用於編碼解碼物件
    private Charset charse = Charset.forName("GBK");
    public static SelectionKey key = null;


    public NServer() throws IOException {
        // 建立Selector物件
        selector = Selector.open();
        // 開啟一個伺服器端通道
        serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress isa = new InetSocketAddress("127.0.0.1", port);
        serverSocketChannel.bind(isa);
        // 設定為非阻塞模式
        serverSocketChannel.configureBlocking(false);
        // 為伺服器通道註冊連線就緒監聽事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("=======Welcome!!!=======");
    }

    public static void main(String args[]) throws IOException {
        new NServer().service();
    }

    private void service() throws IOException {
        // TODO Auto-generated method stub
        // 通過select方法選擇一組鍵，其相應的通道已為 I/O操作準備就緒
        while (selector.select() > 0) {
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> it = keys.iterator();
            while (it.hasNext()) {

                key = it.next();
                // 刪除正在處理的key
                it.remove();
                if (key.isAcceptable()) {
                    SocketChannel sc = serverSocketChannel.accept();
                    if (sc.isConnected()) {
                        System.out.println("連線到:"
                                + sc.socket().getInetAddress() + "--"
                                + sc.socket().getPort());
                    }
                    // 設定為非阻塞模式
                    sc.configureBlocking(false);
                    // 為返回的SocketChannel物件註冊讀就緒和寫就緒監聽
                    sc.register(selector, SelectionKey.OP_READ);
                }

                if (key.isReadable()) {
                    try {
                        readMsg(key);
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }

            }
        }
    }

    private void sendEcho(SelectionKey key,String content) throws IOException {
        if(content.length()>0){
            SocketChannel sc = (SocketChannel) key.channel();
            String echo = "#ServerEcho:"+content+"收到!";
            sc.write(charse.encode(echo));
            System.out.println(echo);
        }
    }

    private void readMsg(SelectionKey key) throws IOException {
        // TODO Auto-generated method stub
        // 獲取該key所對應的SocketChannel
        SocketChannel socketChannel = (SocketChannel) key.channel();
        // 建立一個ByteBuffer用於存放讀取的資料
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        String content = "";
        try {
            while (socketChannel.read(buffer) > 0) {
                // 將極限設定為當前位置，再將當前位置設定為0
                buffer.flip();
                // 對讀取取內容進行解碼
                content += charse.decode(buffer);
            }
            System.out.println("#Client:" + content);
            // 將key對應的Channel設定為準備下一次讀取
            key.interestOps(SelectionKey.OP_READ);
            buffer.clear();
        } catch (IOException e) {
            key.cancel();
            if (key.channel() != null) {
                key.channel().close();
            }
        }
        sendEcho(key,content);
    }
}

客戶端：

package sency.lay.two;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

/**
 * 客戶端
 * 
 * @author sency
 * 
 */
public class NClient {
    private SocketChannel socketChannel;
    private Selector selector;
    private int port = 8000;
    private Charset charse = Charset.forName("GBK");
    public SelectionKey key = null;

    public NClient() throws IOException {
        selector = Selector.open();
        // 建立SocketChannel
        InetSocketAddress isa = new InetSocketAddress("127.0.0.1", port);
        socketChannel = SocketChannel.open();
        socketChannel.connect(isa);
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ);
    }

    public static void main(String args[]) throws IOException {
        System.out.println("=======客戶端=======");

        new NClient().talk();

    }

    private void talk() throws IOException {
          Scanner scan=new Scanner(System.in);
          new MyThread().start();
          while(scan.hasNextLine()){  
              //讀取鍵盤的輸入  
              String line=scan.nextLine();  
              //將鍵盤的內容輸出到SocketChanenel中  
              socketChannel.write(charse.encode(line));  
            System.out.println("#Client:"+line);
          }  


    }

    class MyThread extends Thread{

        public void run() {
            // TODO Auto-generated method stub
            try {
                while (selector.select() > 0) {

                    Set<SelectionKey> keys = selector.selectedKeys();
                    Iterator<SelectionKey> it = keys.iterator();
                    while (it.hasNext()) {

                        key = it.next();
                        it.remove();

                        // TODO Auto-generated method stub
                        if (key.isReadable()) {
                            try {
                                receiveMsg(key);
                            } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }

                    }
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }
    private void receiveMsg(SelectionKey key) throws IOException {
        // TODO Auto-generated method stub
        // 獲取該key所對應的SocketChannel
        SocketChannel socketChannel = (SocketChannel) key.channel();
        // 建立一個ByteBuffer用於存放讀取的資料
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        String content = "";
        try {
            while (socketChannel.read(buffer) > 0) {
                // 將極限設定為當前位置，再將當前位置設定為0
                buffer.flip();
                // 對讀取取內容進行解碼
                content += charse.decode(buffer);
            }
            System.out.println(content);
            // 將key對應的Channel設定為準備下一次讀取
            key.interestOps(SelectionKey.OP_READ);

        } catch (IOException e) {
            if (key != null) {
                key.cancel();
                key.channel().close();
            }
        }
    }
}

水平太低啦，大家不要介意，努力學習ing！

相關推薦

Java簡單實現Socket非阻塞通訊

        用java實現socket C/S通訊很簡單，很多教科書上都有。但是這些通訊模型大都是阻塞式的，其弊端也很明顯：一方必須要接收的到對方的訊息後，才能編輯自己的訊息發出。同樣對方也要一直等待這條訊息收到後才能傳送新的訊息。用網路通訊的知識講，大概就是半雙工通訊

java NIO實現同步非阻塞伺服器

server package net.smgui.util; import java.io.IOException; import java.net.InetSocketAddress; import java.net.Socket; import java.nio.Byt

NIO實現TCP的非阻塞通訊

這一次寫NIO實現非阻塞通訊時遇到了很多問題，我所理解的非阻塞是對於一個使用者而言它的讀寫不會相互制約，而在此次編寫過程中，發現其實非阻塞是相對於多個使用者而言的。 看到網上一個對同步非同步阻塞非阻塞的例子，感覺挺好的，就拷過來了： 老張愛喝茶，廢話不說

java socket通訊I/O阻塞>多執行緒實現非阻塞通訊

簡單的java socket通訊，多個客戶端同時連線，功能可在此基礎上進行擴充套件。效果如圖： server： package com.lb.LB_Socket; import java.io.BufferedReader; import ja

用Java實現非阻塞通訊

用ServerSocket和Socket來編寫伺服器程式和客戶程式，是Java網路程式設計的最基本的方式。這些伺服器程式或客戶程式在執行過程中常常會阻塞。例如當一個執行緒執行ServerSocket的accept()方法時，假如沒有客戶連線，該執行緒就會一直等到有了客戶連

利用OpenSSL實現非阻塞通訊C++程式碼

可以轉載，轉載請註明出處，謝謝！ 這篇博文主要實現瞭如何在win64下基於VS2012實現OpenSSL的非阻塞通訊。參考了以下幾篇博文的內容，表示感謝： 其實關鍵步驟有以下幾步： 1. 讓server和client建立一般的非OpenSSL套接字的

利用Python中SocketServer 實現客戶端與伺服器間非阻塞通訊

利用SocketServer模組來實現網路客戶端與伺服器併發連線非阻塞通訊。 首先，先了解下SocketServer模組中可供使用的類： BaseServer：包含伺服器的核心功能與混合（mix-in）類掛鉤；這個類只用於派生，所以不會生成這個類的例項；可以考慮使用TCPS

Java NIO-非阻塞通訊

NIO(Non-block IO)指非阻塞通訊，相對於其程式設計的複雜性，通常客戶端並不需要使用非阻塞通訊以提高效能，故這裡只有服務端使用非阻塞通訊方式實現 客戶端： package com.test.client; import java.io.DataInputSt

用Java實現非阻塞通訊 和阻塞通訊

用ServerSocket和Socket來編寫伺服器程式和客戶程式，是Java網路程式設計的最基本的方式。這些伺服器程式或客戶程式在執行過程中常常會阻塞。例如當一個執行緒執行ServerSocket的accept()方法時，假如沒有客戶連線，該執行緒就會一直等到有了客戶連線

Netty進階基礎篇之NIO 非阻塞通訊（6）

1、Tcp網路非阻塞通訊 //客戶端 @Test public void client() throws IOExcept

java 非阻塞通訊的例子

package 建立非阻塞的EchoClient; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.

java非阻塞通訊學習

  java非阻塞通訊思想按照書上說的來講，就是你在燒開水也在做飯，不用找兩個人去完成這兩件事情。一個人完成這兩件事就行了，這個人不停的看水是否燒開，飯是否做好 一旦其中某個事情發生就做相應的處理。生活例子讀起來很簡單，百度了很久也沒有找到非阻塞通訊的和阻塞通訊比較的優缺點

【Flask】Flask實現非同步非阻塞請求功能

前言 最近做物聯網專案的時候需要搭建一個非同步非阻塞的HTTP伺服器，經過查詢資料，發現可以使用gevent包。 關於gevent Gevent 是一個 Python 併發網路庫，它使用了基於 libevent 事件迴圈的 greenlet 來提供一個高階

Netty之BIO（同步阻塞IO）、PIO（偽非同步阻塞IO）、NIO（非同步非阻塞IO）、AIO（非同步非阻塞IO）

學習書籍：Netty權威指南 多種IO方式的比較： 1、BIO（同步阻塞IO） 使用ServerSocket繫結IP地址和監聽埠，客戶端發起連線，通過三次握手建立連線，用socket來進行通訊，通過輸入輸出流的方式來進行同步阻塞的通訊 每次客戶端發起連線請求，都會

利用tornado使請求實現非同步非阻塞

基本IO模型 網上搜了很多關於同步非同步，阻塞非阻塞的說法，理解還是不能很透徹，有必要買書看下。 參考：使用非同步 I/O 大大提高應用程式的效能 怎樣理解阻塞非阻塞與同步非同步的區別？ 同步和非同步：主要關注訊息通訊機制（重點在B？）。 同步：A呼叫B，B處理直到獲得結

Java網路程式設計四 非阻塞通訊UDP

轉自 http://blog.csdn.net/alangdangjia/article/details/9065845 import java.io.BufferedReader;    import java.io.ByteArrayInputStream;  

MPI，同步/非同步，阻塞/非阻塞通訊，集合通訊，Gather/Scatter

1. MPI MPI(Message Passing Interface)是一種訊息傳遞介面，是一個訊息傳遞漢書庫的標準說明。在基於MPI程式設計模型中，計算是由一個或多個彼此通過呼叫庫函式進行訊息收、發通訊的程序所組成。MPI為程式設計師提供一個並行環境庫，程式設計師通過

Socket之-非阻塞通訊

本篇文章觀點和例子來自 《Java網路程式設計精解》， 作者為孫衛琴， 出版社為電子工業出版社。       對於用ServerSocket 及 Socket 編寫的伺服器程式和客戶程式, 他們在執行過程中常常會阻塞. 例如, 當一個執行緒執行 ServerSocket 的accept() 方法時, 假

【MPI學習4】MPI並行程式設計模式：非阻塞通訊MPI程式設計

這一章講了MPI非阻塞通訊的原理和一些函式介面，最後再用非阻塞通訊方式實現Jacobi迭代，記錄學習中的一些知識。 （1）阻塞通訊與非阻塞通訊 阻塞通訊呼叫時，整個程式只能執行通訊相關的內容，而無法執行計算相關的內容； 非阻塞呼叫的初衷是儘量讓通訊和計算重疊進行，提高程式整體執行效率。 整體對比見下圖：

關於JAVA NIO是同步非阻塞I/O的解釋

一般來說 I/O 模型可以分為：同步阻塞，同步非阻塞，非同步阻塞，非同步非阻塞 四種IO模型 同步阻塞 IO ： 在此種方式下，使用者程序在發起一個 IO 操作以後，必須等待 IO 操作的完成，只有當真正完成了 IO 操作以後，使用者程序才能執行。 JAVA傳統的 IO 模型屬於此種方式！ 同步非阻塞 IO