2. 程式人生 > >網路程式設計NIO：BIO和NIO

網路程式設計NIO：BIO和NIO

阿新 • • 發佈：2020-11-06

BIO

BIO(Blocking I/O)，同步阻塞，實現模式為一個連線一個執行緒，即當有客戶端連線時，伺服器端需為其單獨分配一個執行緒，如果該連線不做任何操作就會造成不必要的執行緒開銷。BIO是傳統的Java io程式設計，其相關的類和介面在java.io 包下。

BIO適用於連線數目較小且固定的架構，對伺服器資源的要求較高，是JDK1.4以前的唯一選擇，但程式簡單易理解。

BIO程式設計流程

  1. 伺服器端啟動一個SeverSocket

  2. 客戶端啟動Socket對伺服器端發起通訊，預設情況下伺服器端需為每個客戶端建立一個執行緒與之通訊

  3. 客戶端發起請求後，先諮詢伺服器端是否有執行緒響應，如果沒有則會等待或被拒絕

  4. 如果有執行緒響應，客戶端執行緒會等待請求結束後，再繼續執行

簡單程式碼實現

//BIO-伺服器端
public class BIOSever {
    public static void main(String[] args) throws IOException {
        //在BIO中，可以使用執行緒池進行優化
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("伺服器已啟動");

        while (true){
            System.out.println("等待客戶端連線.....（阻塞中）");
            Socket socket = serverSocket.accept();
            System.out.println("客戶端連線");
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    handler(socket);
                }
            });
        }
    }

    //從客服端socket讀取資料
    public static void handler(Socket socket){
        try{
            InputStream inputStream = socket.getInputStream();
            byte[] b = new byte[1024];
            while (true){
                System.out.println("等待客戶端輸入.....（阻塞中）");
                int read = inputStream.read(b);
                if (read != -1){
                    System.out.println(new String(b, 0, read));
                }else {
                    break;
                }
            }
            inputStream.close();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//BIO-客戶端
public class BIOClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 6666);
        OutputStream outputStream = socket.getOutputStream();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()){
            String message = scanner.nextLine();
            if ("exit".equals(message)) {
                break;
            }
            outputStream.write(message.getBytes());
        }
        outputStream.close();
        socket.close();
    }
}

BIO問題分析

從上面程式碼中可以看出BIO程式設計的兩個問題：

  1. 伺服器端在監聽客戶端連線時(serverSocket.accept())，伺服器端處於阻塞狀態，不能處理其他事務

  2. 伺服器端需要為每個客戶端建立一個執行緒，雖然可以用執行緒池來優化，但在併發較大時，執行緒開銷依舊很大

  3. 當連線的客戶端沒有傳送資料時，伺服器端會阻塞在read操作上，等待客戶端輸入，造成執行緒資源浪費

 

NIO

從JDK1.4開始，java提供了一系列改進輸入/輸出的新特性，統稱為NIO，全稱n為new I/O，是同步非阻塞的，所以也有人稱為non-blocking I/O。NIO的相關類都放在java.nio包或其子包下，並對原先java.io包中許多類進行了改寫。

NIO的三大核心

緩衝區(Buffer)

NIO是面向緩衝區, 或者說是面向塊程式設計的。在NIO的IO傳輸中，資料會先讀入到緩衝區，當需要時再從緩衝區寫出，這樣減少了直接讀寫磁碟的次數，提高了IO傳輸的效率。

緩衝區(buffer)本質上是一個可以讀寫資料的記憶體塊，即在記憶體空間中預留了一定的儲存空間，這些儲存空間用來緩衝輸入和輸出的資料，這部分預留的儲存空間就叫緩衝區。

在NIO程式中，通道channel雖然負責資料的傳輸，但是輸入和輸出的資料都必須經過緩衝區buffer。

在java中，緩衝區的相關類都在java.nio包下，其最頂層的類是 Buffer，它是一個抽象類。

Buffer類的4個重要屬性：

  • mark：標記

  • position：位置，下一個要被讀或寫的元素的索引，每次讀寫緩衝區都會改變該值，為下次讀寫做準備

  • limit：表示緩衝區的終點，不能對緩衝區中超過極限的位置進行讀寫操作，且極限是可修改的

  • capacity：容量，即緩衝區的最多可容納的資料量，該值在建立緩衝區時被設立，且不可修改

Buffer類常用方法：

Buffer的常用子類（它們之間最大區別在於底層實現陣列的資料型別）：

  • ByteBuffer：儲存位元組資料到緩衝區

  • CharBuffer：儲存字元資料到緩衝區

  • IntBuffer：儲存整型資料到緩衝區

  • ShortBuffer：儲存短整型資料到緩衝區

  • LongBuffer：儲存長整型資料到緩衝區

  • FloatBuffer：儲存浮點型資料到緩衝區

  • DoubleBuffer：儲存雙精度浮點型資料到緩衝區

ByteBuffer

在Buffer的所有子類中，最常用的還是ByteBuffer，它的常用方法：

 

通道(Channel)

在NIO程式中伺服器端和客戶端之間的資料讀寫不是通過流，而是通過通道來讀寫的。

通道類似於流，都是用來讀寫資料的，但它們之間也是有區別的：

  • 通道是雙向的，即可以讀也可以寫，而流是單向的，只能讀或寫

  • 通道可以實現非同步讀寫資料

  • 通道可以從緩衝區讀資料，也可以把資料寫入緩衝區

java中channel的相關類在java.nio.channel包下。Channel是一個介面，其常用的實現類有：

  • FileChannel：用於檔案的資料讀寫，其真正的實現類為FileChannelImpl

  • DatagramChannel：用於UDP的資料讀寫，其真正的實現類為DatagramChannelImpl

  • ServerSocketChannel：用於監聽TCP連線，每當有客戶端連線時都會建立一個SocketChannel，功能類似ServerSocket，其真正的實現類為ServerSocketChannelImpl

  • SocketChannel：用於TCP的資料讀寫，功能類似節點流+Socket，其真正的實現類為SocketChannelImpl

FileChannel

FileChannel主要用於對本地檔案進行IO操作，如檔案複製等。它的常用方法有：

在檔案傳輸流中有個屬性channel，它預設是空的，可以通過流中的getChanel()方法根據當前檔案流的屬性生成對應的FileChannel。

public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, false, true, append, this);
            }
            return channel;
        }
    }
}

下面是通道使用的程式碼例項：

public class NIOChannel {
    public static void main(String[] args) throws IOException {
    }

    //將資料寫入目標檔案
    public static void writeFile() throws IOException{
        String str = "Hello, gofy";
        //建立檔案輸出流
        FileOutputStream fileOutputStream = new FileOutputStream("f:\\file.txt");
        //根據檔案輸出流生成檔案通道
        FileChannel fileChannel = fileOutputStream.getChannel();
        //建立位元組緩衝區，並將字串轉成位元組存入
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        byteBuffer.put(str.getBytes());
        //注意，在存入後需要進行寫出操作時，需將緩衝區翻轉
        byteBuffer.flip();
        //將緩衝區資料寫入通道
        fileChannel.write(byteBuffer);
        //將檔案輸出流關閉（該方法同時會關閉通道）
        fileOutputStream.close();
    }

    //從檔案中讀取資料
    public static void readFile() throws IOException{
        //建立檔案輸入流
        File file = new File("f:\\file.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        //根據檔案輸入流生成檔案通道
        FileChannel fileChannel = fileInputStream.getChannel();
        //建立位元組緩衝區，大小為檔案大小
        ByteBuffer byteBuffer = ByteBuffer.allocate((int)file.length());
        //將通道資料讀入緩衝區
        fileChannel.read(byteBuffer);
        //同樣，在讀入後需要取出緩衝區內所有資料時，需將緩衝區翻轉
        byteBuffer.flip();
        System.out.println(new String(byteBuffer.array()));
        fileInputStream.close();
    }

    //將檔案資料傳輸到另一個檔案
    public static void readAndWriteFile() throws IOException{
        //建立檔案輸入流和檔案輸出流，並生成對應的通道
        FileInputStream fileInputStream = new FileInputStream("file1.txt");
        FileChannel inputStreamChannel= fileInputStream.getChannel();
        FileOutputStream fileOutputStream = new FileOutputStream("file2.txt");
        FileChannel outputStreamChannel = fileOutputStream.getChannel();
        //建立位元組緩衝區
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        //進行資料讀取
        while (true){
            //在讀取前需清除緩衝區
            byteBuffer.clear();
            //將檔案輸入的通道的資料讀入緩衝區
            int read = inputStreamChannel.read(byteBuffer);
            //當read為-1時，即通道資料已讀取完畢
            if (read == -1){
                break;
            }
            //將緩衝區翻轉後，將緩衝區資料寫入檔案輸出的通道
            byteBuffer.flip();
            outputStreamChannel.write(byteBuffer);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }

    //檔案的複製貼上
    public static void copyAndPaste() throws IOException{
        //複製的檔案輸入流
        FileInputStream fileInputStream = new FileInputStream("f:\\a.jpg");
        FileChannel srcChannel = fileInputStream.getChannel();
        //貼上的檔案輸出流
        FileOutputStream fileOutputStream = new FileOutputStream("f:\\b.jpg");
        FileChannel targetChannel = fileOutputStream.getChannel();
        //使用transferFrom進行復制貼上
        targetChannel.transferFrom(srcChannel, 0, srcChannel.size());
        fileInputStream.close();
        fileOutputStream.close();
    }
}

 

選擇器(Selector)

在NIO程式中，可以用選擇器Selector實現一個選擇器處理多個通道，即一個執行緒處理多個連線。只要把通道註冊到Selector上，就可以通過Selector來監測通道，如果通道有事件發生，便獲取事件通道然後針對每個事件進行相應的處理。這樣，只有在通道(連線)有真正的讀/寫事件發生時，才會進行讀寫操作，大大減少了系統開銷，並且不必為每個連線建立單獨執行緒，就不用去維護過多的執行緒。

選擇器的相關類在java.nio.channels包和其子包下，頂層類是Selector，它是一個抽象類，它的常用方法有：

通道的註冊

在ServerSocketChannel和SocketChannel類裡都有一個註冊方法 register(Selector sel, int ops)，sel為要註冊到的選擇器，ops為該通道監聽的操作事件的型別，可以通過該方法將ServerSocketChannel或SocketChannel註冊到目標選擇器中，該方法會返回一個SelectionKey（真正實現類為SelectionKeyImpl）儲存在註冊的Selector的publicKeys集合屬性裡。SelectionKey儲存了通道的事件型別和該註冊的通道物件，可以通過SelectionKey.channel()方法獲取SelectionKey對應的通道。

每個註冊到選擇器的通道都需定義需進行的操作事件型別，通過檢視SelectionKey類的屬性可以知道操作事件的型別有4種： 

public static final int OP_READ = 1 << 0; //讀操作
public static final int OP_WRITE = 1 << 2; //寫操作
public static final int OP_CONNECT = 1 << 3; //連線操作
public static final int OP_ACCEPT = 1 << 4; //接收操作

選擇器的檢查

我們可以通過選擇器的檢查方法，如select()來得知發生事件的通道數量，當該數量大於為0時，即至少有一個通道發生了事件，就可以使用selectedKeys()方法來獲取所有發生事件的通道對應的SelectionKey，通過SelectionKey中的方法來判斷對應通道中需處理的事件型別是什麼，在根據事件做出相應的處理。

public final boolean isReadable() { //判斷是否是讀操作
    return (readyOps() & OP_READ) != 0;
}

public final boolean isWritable() { //判斷是否是寫操作
    return (readyOps() & OP_WRITE) != 0;
}

public final boolean isConnectable() { //判斷是否是連線操作
    return (readyOps() & OP_CONNECT) != 0;
}

public final boolean isAcceptable() { //判斷是否是接收操作
    return (readyOps() & OP_ACCEPT) != 0;
}

 

NIO實現簡單的聊天群

//伺服器端
public class GroupChatSever {
    private final static int PORT = 6666;//監聽埠
    private Selector selector;//選擇器
    private ServerSocketChannel serverSocketChannel;

    public GroupChatSever(){
        try{
            selector = Selector.open();//開啟選擇器
            serverSocketChannel = ServerSocketChannel.open();//開啟通道
            serverSocketChannel.configureBlocking(false);//將通道設為非阻塞狀態
            serverSocketChannel.socket().bind(new InetSocketAddress(PORT));//通道繫結監聽埠
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);//將通道註冊到選擇器上，事件型別為接收
            listen();
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    //對埠進行監聽
    public void listen(){
        try {
            while (true){
                //檢查註冊通道是否有事件發生，檢查時長為2秒
                int count = selector.select(2000);
                if (count > 0){//如果註冊通道有事件發生則進行處理
                    //獲取所有發生事件的通道對應的SelectionKey
                    Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                    while (keyIterator.hasNext()){
                        SelectionKey key = keyIterator.next();
                        if (key.isAcceptable()){//判斷該key對應的通道是否需進行接收操作
                            //雖然accept()方法是阻塞的，但是因為對通道進行過判斷，
                            //可以確定是有客戶端連線的，所以此時呼叫accept並不會阻塞
                            SocketChannel socketChannel = serverSocketChannel.accept();
                            socketChannel.configureBlocking(false);
                            //接收後，將獲取的客戶端通道註冊到選擇器上，事件型別為讀
                            socketChannel.register(selector, SelectionKey.OP_READ);
                            System.out.println(socketChannel.getRemoteAddress() + "上線!");
                        }
                        if (key.isReadable()){//判斷該key對應的通道是否需進行讀操作
                            readFromClient(key);
                        }
                        //注意當處理完一個通道key時，需將它從迭代器中移除
                        keyIterator.remove();
                    }
                }
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    /**
     * 讀取客戶端發來的訊息
     * @param key 需讀取的通道對應的SelectionKey
     */
    public void readFromClient(SelectionKey key){
        SocketChannel socketChannel = null;
        try{
            //通過SelectionKey獲取對應通道
            socketChannel = (SocketChannel)key.channel();
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            int read = socketChannel.read(byteBuffer);
            if (read > 0){
                String message = new String(byteBuffer.array());
                System.out.println("客戶端: " + message);
                sendToOtherClient(message, socketChannel);
            }
        }catch (IOException e){
            //這裡做了簡化，將所有異常都當做是客戶端斷開連線觸發的異常，實際專案中請不要這樣做
            try{
                System.out.println(socketChannel.getRemoteAddress() + "下線");
                key.cancel();//將該SelectionKey撤銷
                socketChannel.close();//再關閉對應通道
            }catch (IOException e2){
                e2.printStackTrace();
            }
        }
    }

    /**
     * 將客戶端傳送的訊息轉發到其他客戶端
     * @param message 轉發的訊息
     * @param from 傳送訊息的客戶端通道
     * @throws IOException
     */
    public void sendToOtherClient(String message, SocketChannel from) throws IOException{
        System.out.println("訊息轉發中......");
        for (SelectionKey key : selector.keys()){//遍歷選擇器中所有SelectionKey
            Channel channel = key.channel();//根據SelectionKey獲取對應通道
            //排除掉髮送訊息的通道，將訊息寫入到其他客戶端通道
            if (channel instanceof SocketChannel && channel != from){
                SocketChannel socketChannel = (SocketChannel)channel;
                ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBytes());
                socketChannel.write(byteBuffer);
            }
        }
    }

    public static void main(String[] args) {
        GroupChatSever groupChatSever = new GroupChatSever();
    }
}
//客戶端
public class GroupChatClient {
    private final static String SEVER_HOST = "127.0.0.1";//連線的客戶端主機
    private final static int SEVER_PORT = 6666;//連線的客戶端埠
    private Selector selector;//選擇器
    private SocketChannel socketChannel;
    private String username;//儲存客戶端ip地址

    public GroupChatClient(){
        try {
            selector = Selector.open();//開啟選擇器
            socketChannel = SocketChannel.open(new InetSocketAddress(SEVER_HOST, SEVER_PORT));//開啟通道
            socketChannel.configureBlocking(false);//將通道設為非阻塞
            socketChannel.register(selector, SelectionKey.OP_READ);//將通道註冊在選擇器上，事件型別為讀
            username = socketChannel.getLocalAddress().toString().substring(1);//獲取客戶端ip地址
            String message = " 進入聊天群!";
            sendMessage(message);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    //傳送訊息
    public void sendMessage(String message){
        message = username+": "+message;
        try{
            ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBytes());
            socketChannel.write(byteBuffer);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    //讀取從伺服器轉發送過來的訊息
    public void readMessage(){
        try{
            int read = selector.select();
            if (read > 0){
                Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                while (keyIterator.hasNext()){
                    SelectionKey key = keyIterator.next();
                    if (key.isReadable()){
                        SocketChannel socketChannel = (SocketChannel)key.channel();
                        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                        socketChannel.read(byteBuffer);
                        System.out.println(new String(byteBuffer.array()));
                    }
                    keyIterator.remove();
                }
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        final GroupChatClient groupChatClient = new GroupChatClient();
        //客戶端開啟一個執行緒來監聽是否有伺服器轉發來訊息
        new Thread(){
            @Override
            public void run() {
                while (true){
                    groupChatClient.readMessage();
                    try {
                        Thread.currentThread().sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()){
            String message = scanner.nextLine();
            groupChatClient.sendMessage(message);
        }
    }
}

&n

相關推薦

網路程式設計NIO：BIO和NIO

BIO BIO(Blocking I/O)，同步阻塞，實現模式為一個連線一個執行緒，即當有客戶端連線時，伺服器端需為其單獨分配一個執行緒，如果該連線不做任何操作就會造成不必要的執行緒開銷。BIO是傳統的Java io程式設計，其相關的類和介面在java.io 包下。 BIO適用於連線數目較小且固定的架構，對伺

Java基礎：java網路程式設計IO總結(BIO、NIO、AIO)

1.基本概念 在Java網路通訊中，最基本的概念就是Socket程式設計了。Socket又稱“套接字” 向網路發出請求或者應答網路請求。 Socket 和ServerSocket類庫位於 Java.net 包中。ServerSocket用於伺服器端，Socket是建立網路連線時使用的

Java IO：BIO和NIO區別及各自應用場景

引言BIO和NIO是兩種不同的網路通訊模型，現如今NIO已經大量應用在Jetty、ZooKeeper、Netty等開源框架中。一個面向流、一個面向緩衝區一個是阻塞式的、一個非阻塞一個沒有io多路複用器、一個有下面通過一個例子解釋兩者區別：假設當前服務端程式需要同時從與多個客戶

【Java網路程式設計】：JDK API實現OIO和NIO

前言 網路程式設計是Java的一大難點，JDK自帶的api可以實現網路程式設計。 我們將從一個應用程式開始我們對傳輸的學習，這個應用程式只簡單地接受連線，然後向客戶端寫“Hi!”，然後關閉連線。 1. OIO實現 應用程式的阻塞（OIO）版程式碼如下： package

【Java網路程式設計】：Netty實現OIO和NIO

承接上文：https://blog.csdn.net/hxcaifly/article/details/85274664 前言 單純地使用Java JDK來實現網路NIO是一件開發成本非常高的事情。然而，Netty 為它所有的傳輸實現提供了一個通用API，這使得這種

Java 網路IO程式設計總結（BIO、NIO、AIO均含完整例項程式碼）

第一段內容轉載自：http://blog.51cto.com/stevex/1284437 先來個例子理解一下概念，以銀行取款為例： 同步 ： 自己親自出馬持銀行卡到銀行取錢（使用同步IO時，Java自己處理IO讀寫）。 非同步

Qt：Qt實現Winsock網路程式設計—TCP服務端和客戶端通訊（多執行緒）

Qt實現Winsock網路程式設計—TCP服務端和客戶端通訊（多執行緒） 前言 感覺Winsock網路程式設計的api其實和Linux下網路程式設計的api非常像，其實和其他程式語言的網路程式設計都差不太多。博主用Qt實現的，當然不想用黑視窗唄，有介面可以看到，由於GUI程式設計

談談我對java的BIO和NIO的學習的理解

首先io是人機互動的前提 是非常重要滴 java在早期只有bio 後面更新出來了nio nio的作用越來越重要 有的人稱nio為阻塞式io 這點我覺得很不嚴謹 而且對於阻塞與非阻塞的概念我看很多人的說法也不一致 在此我只說說我自己的認識 畢竟認知也是一個不斷提升和完善的

Python學習：網路程式設計'TCP'和'UDP'

網路程式設計：計算機之間做資料交換 客戶端：前端 服務端： 如何將資料傳送到服務端 服務端資料如何下發給客戶端 網路程式設計三要素： ip地址：計算機在網路上的位置 埠號：應用程式 協議：傳輸的方式，對話方式 TCP:需要建立連線，速度慢，可靠安全{打電話} UDP：不需要連線，速度

BIO和NIO

zedosu 關於BIO和NIO的理解 摘要:

AIO、BIO和NIO的區別詳解

IO讀寫時，多路複用機制都會依賴一個事件分離器，負責把源事件的IO分離出來，對應到read/write事件分離器。 事件分離器的兩種模式： 1. Reactor：同步IO 2. Proactor：非同步IO（重疊IO） Reactor 在Rea

linux下C/C++網路程式設計基本：socket實現tcp和udp的例子

簡單的linux下socket程式設計，分別基於TCP和UDP協議實現的簡單程式 linux下socket程式設計可以概括為以下幾個函式的運用： socket() bind() listen

《Linux網路程式設計》： connect()、listen()和accept()三者之間的關係

基於 TCP 的網路程式設計開發分為伺服器端和客戶端兩部分，常見的核心步驟和流程如下：   connect()函式 對於客戶端的 connect() 函式，該函式的功能為客戶端主動連線伺服器，建立連線是通過三次握手，而這個連線的過程是由核心完成，不是這個函式完

基礎概念：IO 和 NIO的區別

轉自：http://ifeve.com/java-nio-vs-io/ Java NIO和IO的主要區別 IO NIO 面向流 面向緩衝 阻塞IO 非阻

系統之間通訊方式（BIO和NIO的區別）（二）

4-3、NIO通訊框架 目前流行的NIO框架非常的多。在論壇上、網際網路上大家討論和使用最多的有以下幾種： 原生JAVA NIO框架：  JAVA NIO通訊框架基於多路複用IO原理，我們將詳細講解它的工作原理。 APACHE MINA 2：  是一個網路應用程

java網路程式設計(三)----同步非阻塞nio及reactor模型

很多剛接觸NIO的人，第一眼看到的就是Java相對晦澀的API，比如：Channel，Selector，Socket什麼的；然後就是一坨上百行的程式碼來演示NIO的服務端Demo，所以這裡我們人性化地簡單介紹一下。 NIO我們一般認為是New I/O（也

淺談 BIO和NIO和AIO 區別

引言 BIO和NIO是兩種不同的網路通訊模型，現如今NIO已經大量應用在Jetty、ZooKeeper、Netty等開源框架中。 一個面向流、一個面向緩衝區 一個是阻塞式的、一個非阻塞 一個沒有io多路複用器、一個有 下面通過一個例子解釋兩者區別： 假設當前服

唯快不破：TCP網路程式設計--非阻塞accept和非阻塞connect

非阻塞accept 當一個已完成的連線準備好被accept的時候，select會把監聽socket標記為可讀。因此，如果用select等待外來的連線時，應該不需要把監聽socket設定為非阻塞模式，因為如果select告訴我們連線已經就緒，accept就不應該被阻塞。不過這樣做的時候有一個BUG：當客戶端在

BIO和NIO的區別

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

阿裏面試題BIO和NIO數量問題附答案和代碼

hello config 試題 代碼 stream accept figure 我們 客戶端請求 一、問題 BIO 和 NIO 作為 Server 端，當建立了 10 個連接時，分別產生多少個線程？ 答案： 因為傳統的 IO 也就是 BIO 是同步線程堵塞的，所以每個連接都