• 阻塞式IO模型，BIO 

   JDK1.4 之前都是采用BIO模式（blocking I/O） ,阻塞式IO，模型如圖

解釋： 應用程序需要從磁盤讀取數據分為兩個階段，1將磁盤數據復制到內核，2將內核數據復制到應用程序空間：

1. 準備數據：應用程序問cpu說：我需要一個aaa.txt 文件，你去給我取來。CPU告訴應用程序，你等著我去給你準備數據（應用程序一直傻傻等待）。CPU轉身問磁盤：磁盤我需要aaa.txt 文件，磁盤開始準備數據，并將數據復制到內核空間中（耗時）
2.  等磁盤把數據給到CPU之后，告訴應用程序數據準備好了，現在給你，CPU將數據從內核復制到用戶空間（耗時）

在上述兩個階段中，對于應用程序的一個線程來說發出讀取文件指令后，這個線程都是一直在等待（阻塞），傻傻什么都不做，如果要想處理其他事情就需要其他線程來做。很明顯這樣的BIO模型性能很低，且消耗資源

jdk中java.io.* 包中都是基于阻塞式io實現的

代碼：

public class BioMain {
     public static void main(String[] args) throws IOException {
        //服務端創建
        ServerSocket serverSocket = new ServerSocket(1234);
        System.out.println("服務端啟動，等待連接");

        //可以一直接收客戶端連接，但是只能有一個客戶端可以讀取數據
        while (true) {
            //accept阻塞，serverSocket等待客戶端的連接
            Socket accept = serverSocket.accept();
            System.out.println("來自客戶端的連接：" + accept.getRemoteSocketAddress());

            InputStream inputStream = accept.getInputStream();

            Scanner scanner = new Scanner(inputStream);
            //針對一個客戶端socket連接進行IO操作
            while (true) {
                String line = scanner.nextLine();//阻塞，一直等待數據進來
                if ("q".equals(line)){
                    break;
                }
                System.out.println("收到數據：" + line);
                accept.getOutputStream().write("I am server ask:".getBytes());
            }
        }
    }
}

 上述代碼中只有一個main 線程，也就只能處理一個連接的請求，如果想處理多個請求，我們可以在服務端采用多線程的方式，也就對每個socket連接都分配一個線程

代碼2：

public class BioMain2 {
    public static void main(String[] args) throws IOException {
        //服務端創建
        ServerSocket serverSocket = new ServerSocket(1234);
        System.out.println("服務端啟動，等待連接");
        while (true) {
            //accept阻塞，serverSocket等待客戶端的連接
            Socket accept = serverSocket.accept();
            System.out.println(Thread.currentThread().getName() + ":來自客戶端的連接：" + accept.getRemoteSocketAddress());
            new Thread(new Runnable() {//實際應用的時候替換成線程池
                @Override
                public void run() {
                    try {
                        InputStream inputStream = accept.getInputStream();
                        Scanner scanner = new Scanner(inputStream);
                        //針對一個客戶端socket連接進行IO操作
                        while (true) {
                            String line = scanner.nextLine();//阻塞，一直等待數據進來
                            if ("q".equals(line)) {
                                break;
                            }
                            System.out.println(Thread.currentThread().getName() +"收到數據：" + line);
                            accept.getOutputStream().write("I am server ask:".getBytes());
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

•  非阻塞式IO模型  NIO，Non-Blocking IO  

模型如圖，應用進程向內核發出讀取文件指令之后，內核就向磁盤發送指令準備數據去了，而應用進程不會阻塞等待去干其他事情了，過一會兒問問數據準備好了沒，如果內核數據還沒準備好，應用進程就繼續干其他事情，一會兒一問數據好了沒，這段時間中數據會從磁盤復制到內核空間，復制完成之后，待到應用進程再次詢問的時候，內核就告訴它數據已經準備好了，在這個時候數據其實還是沒有真正的進入到應用空間，此時應用進程又進入阻塞，等待數據從內核空間復制到應用空間，只不過這個階段要比前一個階段時間要短的多。總結就是第一個階段不阻塞，第二個階段阻塞

非阻塞式IO在Java中，jdk1.4以后有了一個java.nio.* 的包,Java中的nio實現其實是基于非阻塞式IO和多路復用IO模型實現的

• IO復用模型

由于并不是所有的socket連接都要立馬執行任務，IO復用模型，把所有的客戶端連接都暫存到一個Map集合中，然后不斷的循環遍歷看哪些socket需要執行任務，就把它從map集合中獲取處理進行處理

 

代碼3：

public class NioMain {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //設置為非阻塞方式
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(1234));
        System.out.println("NIO 服務端開啟成功。。。");

        Selector selector = Selector.open();
        //注冊監聽的事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        //緩存區
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        while (true){
            //循環監聽客戶端
            int select = selector.select();
            if (select==0){
                continue;
            }
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()){
                SelectionKey selectionKey = iterator.next();
                if (selectionKey.isAcceptable()){
                    ServerSocketChannel channel = (ServerSocketChannel) selectionKey.channel();
                    SocketChannel accept = channel.accept();
                    System.out.println("接收到客戶端請求："+accept.getRemoteAddress());
                    accept.configureBlocking(false);
                    //將客戶端過來的channel設置成讀取狀態
                    accept.register(selector,SelectionKey.OP_READ);
                }
                if (selectionKey.isReadable()){
                    SocketChannel channel = (SocketChannel) selectionKey.channel();
                    //通過channel將數據讀取到緩存中
                    channel.read(buffer);
                    String str = new String(buffer.array());
                    buffer.clear();
                    System.out.println("接收到數據："+str+"——來自："+channel.getRemoteAddress());

                    //回寫數據
                    channel.write(ByteBuffer.wrap("I am form Nio Server".getBytes()));
                }
                iterator.remove();
            }
        }
    }
}

 

 

 

推薦：https://www.cnblogs.com/Jack-Blog/p/11991240.html