NIO同步阻塞與同步非阻塞

BIO與NIO

IO為同步阻塞形式,NIO為同步非阻塞形式,NIO並沒有實現非同步,在JDK1.7後升級NIO庫包，支援非同步非阻塞
同學模型NIO2.0(AIO)

BIO（同步阻塞式IO）

同步阻塞式IO，伺服器實現模式為一個連線一個執行緒，即客戶端有連線請求時伺服器端就需要啟動一個執行緒進行處理，如果這個連線不做任何事情會造成不必要的執行緒開銷，當然可以通過執行緒池機制改善。

NIO（同步非阻塞式IO）

同步非阻塞式IO，伺服器實現模式為一個請求一個執行緒，即客戶端傳送的連線請求都會註冊到多路複用器上，多路複用器輪詢到連線有I/O請求時才啟動一個執行緒進行處理。

AIO（非同步非阻塞式IO）

非同步非阻塞式IO，伺服器實現模式為一個有效請求一個執行緒，客戶端的I/O請求都是由OS先完成了再通知伺服器應用去啟動執行緒進行處理。

BIO（IO）與NIO區別

其本質就是阻塞和非阻塞的區別

什麼是阻塞？

應用程式在獲取網路資料的時候,如果網路傳輸資料很慢，就會一直等待,直到傳輸完畢為止。

什麼是非阻塞？

應用程式直接可以獲取已經準備就緒好的資料,無需等待。

同步時，應用程式會直接參與IO讀寫操作,並且我們的應用程式會直接阻塞到某一個方法上,直到資料準備就緒；或者採用輪訓的策略實時檢查資料的就緒狀態,如果就緒則獲取資料.
非同步時

偽非同步

問題思考

如何解決同步阻塞IO？
答：使用偽非同步阻塞IO（多執行緒）！

由於BIO一個客戶端需要一個執行緒去處理，因此我們進行優化，後端使用執行緒池來處理多個客戶端的請求接入，形成客戶端個數M：執行緒池最大的執行緒數N的比例關係，其中M可以遠遠大於N，通過執行緒池可以靈活的調配執行緒資源，設定執行緒的最大值，防止由於海量併發接入導致執行緒耗盡。

原理：

當有新的客戶端接入時，將客戶端的Socket封裝成一個Task（該Task任務實現了java的Runnable介面）投遞到後端的執行緒池中進行處理，由於執行緒池可以設定訊息佇列的大小以及執行緒池的最大值，因此，它的資源佔用是可控的，無論多少個客戶端的併發訪問，都不會導致資源的耗盡或宕機。

使用多執行緒支援多個請求

伺服器實現模式為一個連線一個執行緒，即客戶端有連線請求時伺服器端就需要啟動一個執行緒進行處理，如果這個連線不做任何事情會造成不必要的執行緒開銷，當然可以通過執行緒池機制改善。

程式碼示例

Tcp服務端

public class TcpServer {
    public static void main(String[] args) throws IOException {
        System.out.println("Socket tcp服務端啟動。。。。");
        ServerSocket serverSocket = new ServerSocket(8080);
        //等待客戶端請求
        try {
            while (true) {
                Socket accept = serverSocket.accept();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try{
                            InputStream inputStream = accept.getInputStream();
                            //轉換成string型別
                            byte[] bytes = new byte[1024];
                            int read = inputStream.read(bytes);
                            String str = new String(bytes, 0, read);
                            System.out.println("服務端接受客戶端內容："+str);

                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                }).start();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            serverSocket.close();
        }
    }
}

Tcp客戶端

public class TcpClient {
    public static void main(String[] args) throws IOException {
        System.out.println("Socket tcp客戶端啟動...");
        Socket socket = new Socket("127.0.0.1", 8080);
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("勒布朗-詹姆斯".getBytes());
        socket.close();
    }
}

執行結果

伺服器在什麼時候會被等待？

在伺服器端沒有收到客戶端任何資料的時候，一直等待。則被稱為伺服器阻塞IO。

注意⚠️：

但是，偽非同步沒有真正解決阻塞IO核心。
當我們頻繁建立執行緒時，他會佔電腦CPU記憶體，導致電腦宕機，由此，我們在用偽非同步處理同步阻塞IO的時候推薦使用執行緒池來管理！

使用執行緒池管理執行緒

將上面TcpServer改成：

public class TcpServer {
    public static void main(String[] args) throws IOException {
        System.out.println("Socket tcp服務端啟動。。。。");
        ExecutorService executorService = Executors.newCachedThreadPool();
        ServerSocket serverSocket = new ServerSocket(8080);
        //等待客戶端請求
        try {
            while (true) {
                Socket accept = serverSocket.accept();
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {
                        try{
                            InputStream inputStream = accept.getInputStream();
                            //轉換成string型別
                            byte[] bytes = new byte[1024];
                            int read = inputStream.read(bytes);
                            String str = new String(bytes, 0, read);
                            System.out.println("服務端接受客戶端內容："+str);

                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                });
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            serverSocket.close();
        }
    }
}

TcpClient程式碼不變。

IO模型關係

NIO非阻塞程式碼

NIO客戶端

public class NioClient {
    //  nio非同步非阻塞IO
    public static void main(String[] args) throws IOException {
        System.out.println("客戶端已經啟動...");
        //1、建立通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8080));
        //2、切換非同步非阻塞
        sChannel.configureBlocking(false);
        //3、指定緩衝區大小
        ByteBuffer allocate = ByteBuffer.allocate(1024);

        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入內容：");
        while (scanner.hasNext()){
            System.out.println("請輸入內容：");
            String str = scanner.next();
            allocate.put((new Date().toString()+"\n"+str).getBytes());
            //4、切換到讀取模式
            allocate.flip();
            sChannel.write(allocate);
            allocate.clear();

        }
        sChannel.close();
    }
}

NIO伺服器端

public class NioServer {
    public static void main(String[] args) throws IOException {
        System.out.println("服務端已經啟動...");
        //1、建立通道
        ServerSocketChannel sChannel = ServerSocketChannel.open();
        //2、切換非同步非阻塞
        sChannel.configureBlocking(false);
        //3、繫結連線
        sChannel.bind(new InetSocketAddress(8080));
        //4、獲取選擇器
        Selector selector =Selector.open();
        //5、將通道註冊到選擇器，並且"指定監聽接受事件"。
        sChannel.register(selector, SelectionKey.OP_ACCEPT);
        //6、輪訓式 獲取選擇"已經準備就緒"的事件
        while (selector.select()>0){
            // 7.獲取當前選擇器所有註冊的"選擇鍵(已經就緒的監聽事件)"
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                //8.獲取準備就緒的事件
                SelectionKey sk = iterator.next();
                //9.判斷具體是什麼事件準備就緒
                if(sk.isAcceptable()){
                    // 10.若"接受就緒",獲取客戶端連線
                    SocketChannel socketChannel = sChannel.accept();
                    //11.設定阻塞模式
                    socketChannel.configureBlocking(false);
                    //12.將該通道註冊到伺服器上
                    socketChannel.register(selector, SelectionKey.OP_READ);
                }else if(sk.isReadable()){
                    // 13.獲取當前選擇器"就緒" 狀態的通道
                    SocketChannel socketChannel=(SocketChannel)sk.channel();
                    // 14.讀取資料
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int len=0;
                    while ((len=socketChannel.read(buffer))>0){
                        buffer.flip();
                        System.out.println(new String(buffer.array(),0,len));
                        buffer.clear();
                    }
                }
            }

            iterator.remove();
        }
        sChannel.close();
    }
}

執行結果
客戶端：

服務端：

選擇KEY

1、SelectionKey.OP_READ
2、SelectionKey.OP_WRITE
3、SelectionKey.OP_ACCEPT
4、SelectionKey.OP_CONNECT

如果你對不止一種事件感興趣，那麼可以用“位或”操作符將常量連線起來，如下：
int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
在SelectionKey類的原始碼中我們可以看到如下的4中屬性，四個變數用來表示四種不同型別的事件：可讀、可寫、可連線、可接受連線