從Java IO到Java NIO：如何理解阻塞和非阻塞I/O的區別？

作者：你的老師父 2023-07-31 08:55:01

Java NIO是非阻塞的，因為它基于選擇器和通道實現了非阻塞I/O，支持同時處理多個通道的I/O事件，從而提高了I/O操作的效率和響應性能。相比之下，傳統的Java IO（也稱為IO流）是阻塞的，因為它只能同時處理一個輸入/輸出流，當進行輸入/輸出操作時，線程會一直阻塞，直到數據傳輸完成或者發生異常。

Java NIO實現非阻塞I/O

在Java中，阻塞I/O（Blocking I/O）和非阻塞I/O（Non-blocking I/O）是兩種不同的I/O模式。

阻塞I/O模式下，當應用程序進行輸入/輸出操作時，線程會一直阻塞，直到數據傳輸完成或者發生異常。在此期間，線程無法執行其他任務，因此阻塞I/O模式具有較低的效率和響應性能。

非阻塞I/O模式下，當應用程序進行輸入/輸出操作時，線程會立即返回，并且不會等待數據傳輸完成。在此期間，線程可以執行其他任務，因此非阻塞I/O模式具有較高的效率和響應性能。

Java NIO中的非阻塞I/O是基于選擇器（Selector）和通道（Channel）的。選擇器可以監聽多個通道上的I/O事件，并在有事件發生時通知應用程序，從而實現非阻塞I/O操作。通道則是用于輸入/輸出操作的對象，可以是文件通道或網絡通道。

1、創建通道

通道是Java NIO中用于輸入/輸出操作的對象，可以通過SocketChannel、ServerSocketChannel、DatagramChannel等創建網絡通道，或者通過FileChannel創建文件通道。在這里，我們以SocketChannel為例創建網絡通道。

SocketChannel channel = SocketChannel.open();

2、將通道設置為非阻塞模式

通過調用通道的configureBlocking(false)方法，將通道設置為非阻塞模式。在非阻塞模式下，通道的讀取和寫入操作不會阻塞線程，而是立即返回。

channel.configureBlocking(false);

3、創建選擇器

選擇器是Java NIO中用于監聽多個通道的I/O事件的對象，用于實現非阻塞I/O。可以通過Selector.open()方法創建選擇器。

Selector selector = Selector.open();

4、將通道注冊到選擇器上

通過調用通道的register()方法，將通道注冊到選擇器上，并指定要監聽的事件類型，例如讀取事件、寫入事件、連接事件、接受事件等。在這里，我們注冊了讀取事件。

channel.register(selector, SelectionKey.OP_READ);

5、輪詢選擇器

通過調用選擇器的select()方法，輪詢選擇器上注冊的通道，當有通道上的I/O事件就緒時，select()方法會返回就緒的通道數量。

while (true) {
    selector.select();
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        // 處理就緒的通道
        keyIterator.remove();
    }
}

6、處理就緒的通道

通過調用選擇器的selectedKeys()方法，獲取所有就緒的通道，并進行相應的讀取或寫入操作。在這里，我們實現了從通道讀取數據的操作。

while (true) {
    selector.select();
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        if (key.isReadable()) {
            SocketChannel channel = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = channel.read(buffer);
            while (bytesRead > 0) {
                buffer.flip();
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get());
                }
                buffer.clear();
                bytesRead = channel.read(buffer);
            }
            if (bytesRead == -1) {
                channel.close();
            }
        }
        keyIterator.remove();
    }
}

需要注意的是，在非阻塞I/O模式下，讀取和寫入操作通常需要多次調用，直到完整的數據傳輸完成。在讀取操作中，需要將數據從通道讀取到緩沖區，并判斷緩沖區中是否已經讀取完畢。

此外，在非阻塞I/O模式下，發生異常的可能性比較高，因此需要進行異常處理。可以通過選擇器的selectedKeys()方法和SelectionKey的readyOps()方法，判斷通道是否出現異常，并進行相應的處理。

以下是完整的示例代碼。在這個例子中，我們使用了一個簡單的Echo服務器，將客戶端發送的消息原樣返回。

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.util.Iterator;
import java.util.Set;

public class NonBlockingServer {
    public static void main(String[] args) throws IOException {
        // 創建服務器套接字通道
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.socket().bind(new InetSocketAddress(9999));
        serverChannel.configureBlocking(false);

        // 創建選擇器
        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Server started on port 9999");

        while (true) {
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                if (key.isAcceptable()) {
                    // 處理連接事件
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    SocketChannel clientChannel = channel.accept();
                    clientChannel.configureBlocking(false);
                    clientChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("Client connected: " + clientChannel.getRemoteAddress());
                } else if (key.isReadable()) {
                    // 處理讀取事件
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = channel.read(buffer);
                    while (bytesRead > 0) {
                        buffer.flip();
                        while (buffer.hasRemaining()) {
                            channel.write(buffer);
                        }
                        buffer.clear();
                        bytesRead = channel.read(buffer);
                    }
                    if (bytesRead == -1) {
                        channel.close();
                    }
                }
                keyIterator.remove();
            }
        }
    }
}

問題：selector.select()是阻塞，為什么還說NIO是非阻塞的呢？

selector.select()方法確實會阻塞，直到有至少一個通道準備好進行I/O操作或者等待超時或中斷。但是，需要注意的是，這種阻塞只會影響當前的線程，不會影響應用程序的其他線程。

在服務端線程調用選擇器的select()方法時，只有當前服務端線程會被阻塞，而不是客戶端線程。

客戶端的阻塞和非阻塞I/O操作取決于具體的實現。對于阻塞I/O模式，客戶端線程在進行輸入/輸出操作時，會一直阻塞，直到數據傳輸完成或者發生異常。對于非阻塞I/O模式，客戶端線程在進行輸入/輸出操作時，會立即返回，并且不會等待數據傳輸完成。在此期間，客戶端線程可以執行其他任務。

因此，Java NIO仍然可以稱為非阻塞I/O。

Java NIO提供了一種基于事件驅動的I/O模型，應用程序使用選擇器（Selector）來注冊通道（Channel）上的I/O事件，并在有事件發生時進行相應的處理。在選擇器上調用select()方法會阻塞當前線程，直到至少有一個通道上注冊的事件發生，此時select()方法會返回，應用程序可以通過selectedKeys()方法獲取就緒的事件。由于選擇器可以同時監聽多個通道，因此Java NIO可以同時處理多個通道上的I/O事件，從而提高了I/O操作的效率和響應性能。

需要注意的是，雖然選擇器的select()方法會阻塞當前線程，但是可以通過調用選擇器的wakeup()方法中斷阻塞，使得select()方法立即返回。此外，可以在選擇器上設置超時時間，使得select()方法在指定時間內返回，避免長時間的無限阻塞。

實戰Java NIO中實現文件I/O（File I/O）和網絡I/O（Network I/O）

文件I/O（File I/O）

Java NIO中的文件I/O是通過FileChannel來實現的。FileChannel類提供了讀取和寫入文件的方法，而ByteBuffer類則用于存儲讀取和寫入的數據。

以下是實現文件I/O的詳細步驟：

步驟1：獲取FileChannel實例

在進行文件I/O之前，需要先獲取FileChannel實例。可以通過FileInputStream或FileOutputStream來獲取FileChannel實例，例如：

FileInputStream fileInputStream = new FileInputStream("file.txt");
FileChannel fileChannel = fileInputStream.getChannel();

步驟2：創建ByteBuffer

在進行文件I/O之前，需要先創建ByteBuffer實例，用于存儲讀取和寫入的數據。可以通過ByteBuffer的allocate方法創建ByteBuffer實例，例如：

ByteBuffer buffer = ByteBuffer.allocate(1024);

步驟3：讀取文件數據

（1）從FileChannel中讀取數據

可以通過FileChannel的read方法從文件中讀取數據，并將數據存儲到ByteBuffer中。read方法有兩個重載版本：

int read(ByteBuffer dst) throws IOException;
long read(ByteBuffer[] dsts, int offset, int length) throws IOException;

第一個版本的read方法將數據讀取到單個ByteBuffer中，返回值為讀取的字節數。如果返回值為-1，表示已經讀取到了文件的末尾。

第二個版本的read方法將數據讀取到多個ByteBuffer中，返回值為讀取的字節數。如果返回值為-1，表示已經讀取到了文件的末尾。

以下是使用第一個版本read方法的示例代碼：

int bytesRead = fileChannel.read(buffer);
while (bytesRead != -1) {
    buffer.flip();
    while (buffer.hasRemaining()) {
        System.out.print((char) buffer.get());
    }
    buffer.clear();
    bytesRead = fileChannel.read(buffer);
}

上述代碼首先通過FileChannel的read方法將數據讀取到ByteBuffer中，并返回讀取的字節數。隨后，通過flip方法將ByteBuffer從寫模式切換為讀模式，并通過get方法讀取ByteBuffer中的數據。當ByteBuffer中的數據被讀取完畢后，通過clear方法將ByteBuffer從讀模式切換為寫模式，并再次調用FileChannel的read方法讀取文件中的數據，直到文件中的所有數據被讀取完畢。

（2）向FileChannel中寫入數據

可以通過FileChannel的write方法向文件中寫入數據，例如：

byte[] data = "Hello, World!".getBytes();
ByteBuffer buffer = ByteBuffer.wrap(data);
int bytesWritten = fileChannel.write(buffer);

上述代碼首先將數據存儲到ByteBuffer中，隨后調用FileChannel的write方法將數據寫入到文件中。

步驟4：關閉FileChannel

在使用完FileChannel后，需要調用其close方法關閉FileChannel，例如：

fileChannel.close();

完整的代碼示例：

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileIODemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("file.txt");
        FileChannel fileChannel = fileInputStream.getChannel();

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = fileChannel.read(buffer);
        while (bytesRead != -1) {
            buffer.flip();
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get());
            }
            buffer.clear();
            bytesRead = fileChannel.read(buffer);
        }

        fileChannel.close();
    }
}

網絡I/O（Network I/O）

Java NIO中的網絡I/O是通過SocketChannel和ServerSocketChannel來實現的，它們分別用于客戶端和服務端的網絡通信。

以下是實現網絡I/O的詳細步驟：

步驟1：獲取SocketChannel或ServerSocketChannel實例

在進行網絡I/O之前，需要先獲取SocketChannel或ServerSocketChannel實例。可以通過SocketChannel或ServerSocketChannel的open方法獲取相應的實例，例如：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("www.example.com", 80));

或：

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(8080));

步驟2：創建ByteBuffer

在進行網絡I/O之前，需要先創建ByteBuffer實例，用于存儲讀取和寫入的數據。可以通過ByteBuffer的allocate方法創建ByteBuffer實例，例如：

ByteBuffer buffer = ByteBuffer.allocate(1024);

步驟3：讀取網絡數據

（1）從SocketChannel中讀取數據

可以通過SocketChannel的read方法從網絡中讀取數據，并將數據存儲到ByteBuffer中。read方法的用法與文件I/O中的read方法相同，這里不再贅述。

以下是使用SocketChannel的read方法的示例代碼：

int bytesRead = socketChannel.read(buffer);
while (bytesRead != -1) {
    buffer.flip();
    while (buffer.hasRemaining()) {
        System.out.print((char) buffer.get());
    }
    buffer.clear();
    bytesRead = socketChannel.read(buffer);
}

上述代碼首先通過SocketChannel的read方法將數據讀取到ByteBuffer中，并返回讀取的字節數。隨后，通過flip方法將ByteBuffer從寫模式切換為讀模式，并通過get方法讀取ByteBuffer中的數據。當ByteBuffer中的數據被讀取完畢后，通過clear方法將ByteBuffer從讀模式切換為寫模式，并再次調用SocketChannel的read方法讀取網絡中的數據，直到網絡中的所有數據被讀取完畢。

（2）向SocketChannel中寫入數據

可以通過SocketChannel的write方法向網絡中寫入數據，例如：

byte[] data = "Hello, World!".getBytes();
ByteBuffer buffer = ByteBuffer.wrap(data);
int bytesWritten = socketChannel.write(buffer);

上述代碼首先將數據存儲到ByteBuffer中，隨后調用SocketChannel的write方法將數據寫入到網絡中。

步驟4：關閉SocketChannel或ServerSocketChannel

在使用完SocketChannel或ServerSocketChannel后，需要調用其close方法關閉SocketChannel或ServerSocketChannel，例如：

socketChannel.close();

或：

serverSocketChannel.close();

:完整的代碼示例：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NetworkIODemo {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("www.example.com", 80));

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = socketChannel.read(buffer);
        while (bytesRead != -1) {
            buffer.flip();
            while (buffer.hasRemaining()) {
                System.out.print((char) buffer.get());
            }
            buffer.clear();
            bytesRead = socketChannel.read(buffer);
        }

        socketChannel.close();
    }
}

責任編輯：姜華來源：今日頭條

Java NIO 非阻塞阻塞

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

從Java IO到Java NIO：如何理解阻塞和非阻塞I/O的區別？

Java NIO實現非阻塞I/O

1、創建通道

2、將通道設置為非阻塞模式

3、創建選擇器

4、將通道注冊到選擇器上

5、輪詢選擇器

6、處理就緒的通道

問題：selector.select()是阻塞，為什么還說NIO是非阻塞的呢？

實戰Java NIO中實現文件I/O（File I/O）和網絡I/O（Network I/O）

文件I/O（File I/O）

步驟1：獲取FileChannel實例

步驟2：創建ByteBuffer

步驟3：讀取文件數據

（1）從FileChannel中讀取數據

（2）向FileChannel中寫入數據

步驟4：關閉FileChannel

網絡I/O（Network I/O）

步驟1：獲取SocketChannel或ServerSocketChannel實例

步驟2：創建ByteBuffer

步驟3：讀取網絡數據

（1）從SocketChannel中讀取數據

（2）向SocketChannel中寫入數據

步驟4：關閉SocketChannel或ServerSocketChannel