2. 程式人生 > >Java NIO系列4：通道和選擇器

Java NIO系列4：通道和選擇器

阿新 • • 發佈：2019-02-19

前言

今天加班回來，終於有時間繼續更新NIO的文章了。在前一篇文章我們講解了緩衝區的知識，並通過程式碼演示瞭如何使用緩衝區的API完成一些操作。這裡要講的通道於緩衝區關係密切，簡單來說，緩衝區是填充資料的載體，而通道則可以理解為傳輸資料的載體。回憶在TCP/IP中建立握手的過程，傳送端有一個傳送緩衝區而接受端有一個接收緩衝區，程序從緩衝區中取資料，之後緩衝區又可以被填滿，而傳輸資料的網路則可以理解為通道。

通道基礎

相比JDK1.4之前的BIO，NIO一個重大的改變就是由原來的每次的連線都會建立一個新的執行緒區執行，變為只為每個請求建立執行緒，因為如果一個請求需要建立多次連線的話，BIO的效率就非常低下了。NIO處理事件的模型被稱為反應器模型。就是在每個請求到達的時候不會立即進行處理，而是會有一個分發執行緒將處理請求分發給具體的處理執行緒進行處理。這樣設計的好處在於能夠提高吞吐量，提高效能。

那麼，這裡要提到的通道有什麼關係呢？在服務端和客戶端有一個專門管理通道的物件，這個物件能夠監控每個通道的事件（後臺的實現邏輯就是不斷輪詢每個通道所註冊的事件，並判斷是否滿足要求），如果這個物件發現某個通道所註冊的事件發生了，那麼註冊該事件的通道就可以執行一些自己的處理。

在通道API中，頂層介面是Channel，程式碼如下：

package java.nio.channels;
public interface Channel
{
public boolean isOpen( );
public void close( ) throws IOException;
}

在該介面中知有開啟和關閉通道的方法，那麼這兩個方法夠用嗎？當然不夠，實際上更具體的方法都在不同的實現類中。而在通道的實現類中又可以分為兩類：FileChannel和SocketChannel。這兩種通道的開啟方式如下：

// 開啟Socket通道
SocketChannel sc = SocketChannel.open( );
sc.connect (new InetSocketAddress ("somehost", someport));
ServerSocketChannel ssc = ServerSocketChannel.open( );
ssc.socket( ).bind (new InetSocketAddress (somelocalport));
// 開啟UDP通道
DatagramChannel dc = DatagramChannel.open( );
// 開啟檔案通道
RandomAccessFile raf = new
 
 RandomAccessFile ("somefile", "r");
FileChannel fc = raf.getChannel( );

通道實戰

通過以上的介紹，我們對通道有了一個基本的認識，下面主要演示如何通過程式碼的方式使用NIO中通道（由於在NIO應用最廣的是Socket通道，所以下面的例子都是基於Socket通道）。

通道的簡單使用

下面通過從通道拷貝資料帶緩衝區為例，對通道的基本使用做一個簡單演示：

package com.rhwayfun.patchwork.nio.channel;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;

/**
 * @author: rhwayfun
 * @since: 2016-05-28
 */
public class ChannelCopy {
    public static void main(String[] args) throws IOException {
        // 建立一個源通道
        ReadableByteChannel source = Channels.newChannel(System.in);
        // 建立一個目標通道
        WritableByteChannel dest = Channels.newChannel(System.out);
        channelCopy(source,dest);
        // 關閉通道
        source.close();
        dest.close();
    }

    /**
     * 通道拷貝
     * @param source
     * @param dest
     * @throws IOException
     */
    private static void channelCopy(ReadableByteChannel source, WritableByteChannel dest) throws IOException {
        // 申請16 * 1024位元組大小的通道
        ByteBuffer buffer = ByteBuffer.allocate(16 * 1024);
        // 呼叫read方法讀取緩衝區的資料
        while (source.read(buffer) != -1){
            // 翻轉緩衝區，執行的操作：
            // 1、將limit的位置設為position之後的一個位置
            // 2、將position的位置重置未0
            buffer.flip();
            // 當緩衝區還有資料的話就寫到目標通道中
            while (buffer.hasRemaining()){
                dest.write(buffer);
            }
            // 清空緩衝區
            buffer.clear();
        }
    }

    /**
     * 通道拷貝的另一種方式
     * @param source
     * @param dest
     * @throws IOException
     */
    private static void channelCopy2(ReadableByteChannel source, WritableByteChannel dest) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(16 * 1024);
        while (source.read(buffer) != -1){
            // 翻轉緩衝區
            buffer.flip();
            // 將緩衝區的資料寫道目標通道
            dest.write(buffer);
            // 如果只寫了一部分資料，將空間進行壓縮，可以重複利用空間
            buffer.compact();
        }
        // 翻轉緩衝區
        buffer.flip();
        // 將剩餘的資料寫入目標緩衝區
        while (buffer.hasRemaining()){
            dest.write(buffer);
        }
    }
}

TCP伺服器

在前面提到有一個物件對服務端和客戶端的通道進行管理，這個物件就是Selector，可以理解為選擇器，這個選擇器就是為通道服務的。伺服器和客戶端可以註冊自己感興趣的事件，這樣Selector就可以不同的多個通道伺服器的狀態。通常Selector上可以註冊的事件型別如下：

事件描述 事件定義
服務端接收客戶端連線事件 SelectionKey.OP_ACCEPT(16)
客戶端連線服務端事件 SelectionKey.OP_CONNECT(8)
讀事件 SelectionKey.OP_READ(1)
寫事件 SelectionKey.OP_WRITE(4)

比如伺服器在Selector物件上註冊了OP_ACCEPT事件，那麼當有客戶端連線上的時候，該事件就可以被響應。

下面實現了一個簡單的TCP伺服器和客戶端：

客戶端

package com.rhwayfun.patchwork.nio.selector;

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

/**
 * @author: rhwayfun
 * @since: 2016-05-28
 */
public class SelectorClient {

    // 連線的主機
    private String host;
    // 主機的埠
    private int port;
    // 選擇器
    private Selector selector;
    // 通道
    private SocketChannel socketChannel;

    public SelectorClient(String host,int port){
        this.host = host;
        this.port = port;
        try {
            init();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void init() throws IOException {
        // 開啟一個選擇器
        selector = Selector.open();
        // 開啟一個通道
        socketChannel = SocketChannel.open(new InetSocketAddress(host,port));
        // 要繫結的地址
        //SocketAddress remoteAddress = new InetSocketAddress(host,port);
        // 繫結到指定的地址
        //socketChannel.bind(remoteAddress);
        // 配置為非阻塞模式
        socketChannel.configureBlocking(false);
        // 註冊到選擇器上
        socketChannel.register(selector, SelectionKey.OP_READ);

        // 監聽來自服務端的響應
        new SelectorThread(selector).start();
    }

    public void writeDataToServer(String message) throws IOException {
        ByteBuffer writeBuffer = ByteBuffer.wrap(message.getBytes("UTF-8"));
        socketChannel.write(writeBuffer);
    }

    public static void main(String[] args) throws IOException {
        SelectorClient client = new SelectorClient("localhost",6666);
        client.writeDataToServer("我是一個客戶端");
    }
}

伺服器

package com.rhwayfun.patchwork.nio.selector;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.SocketAddress;
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;

/**
 * @author: rhwayfun
 * @since: 2016-05-28
 */
public class SelectorServer {

    // 伺服器監聽的埠
    private static final int PORT = 6666;
    // 處理資料的緩衝區
    private ByteBuffer buffer = ByteBuffer.allocate(1024);
    // 歡迎訊息
    private static final String GREETING = "Welcome to here.";

    public static void main(String[] args) {
        new SelectorServer().start(args);
    }

    private void start(String[] args) {
        int port = PORT;
        if (args.length == 1){
            port = Integer.valueOf(args[0]);
        }
        System.out.println("listening on port " + port);
        Iterator<SelectionKey> iterator = null;
        try {
            //建立一個ServerChannel
            ServerSocketChannel serverChannel = ServerSocketChannel.open();
            //獲取通道關聯的Socket物件
            ServerSocket serverSocket = serverChannel.socket();
            //要繫結的地址
            SocketAddress address = new InetSocketAddress(port);
            //建立需要註冊的選擇器
            Selector selector = Selector.open();

            //把socket物件繫結到指定的地址
            serverSocket.bind(address);

            //配置為非阻塞模式
            serverChannel.configureBlocking(false);

            //註冊通道到選擇器
            //第二個引數表名serverChannel感興趣的事件是OP_ACCEPT型別的事件
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);

            // 選擇器不斷迴圈從選擇器中選取已經準備好的通道進行操作
            // 選取之後，會對其感興趣的事件進行處理。將感興趣的事件
            // 處理完畢後將key從集合中刪除，表示該通道的事件已經處
            // 理完畢

            while (true){
                // 這個操作可能會被阻塞，因為不知道註冊在這個選擇器上的通道是否準備好了
                int n = selector.select();
                if (n == 0){
                    continue;
                }

                // 獲取SelectionKey的迭代器物件
                iterator  = selector.selectedKeys().iterator();

                while (iterator.hasNext()){
                    // 獲取這個key關聯的通道
                    SelectionKey key = iterator.next();
                    // 判斷感興趣的事件型別
                    if (key.isAcceptable()){
                        // 這裡可以強制轉換為ServerSocketChannel
                        // 因為在這個選擇器上目前只註冊了一個該型別的通道
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        // 呼叫accept方法可以得到連線到此地址的客戶端連線
                        SocketChannel channel = server.accept();

                        // 註冊客戶端連線到選擇器上，並把感興趣的事件型別設為可讀型別
                        registerChannel(selector,channel,SelectionKey.OP_READ);

                        // 給客戶端傳送響應訊息
                        sayHello(channel);
                    }

                    // 如果是可讀型別的事件，則獲取傳輸過來的資料
                    if (key.isReadable()){
                        readDataFromClient(key);
                    }

                    // 將已經處理的key從集合中刪除
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            iterator.remove();
        }

    }

    /**
     *
     * @param key
     */
    private void readDataFromClient(SelectionKey key) throws IOException {
        // 獲取key管理的Channel物件
        SocketChannel channel = (SocketChannel) key.channel();
        // 讀取之前需要清空緩衝區
        buffer.clear();
        if (channel.read(buffer) < 0){
            channel.close();
        }else {
            buffer.flip();
            String receiveMsg = Charset.forName("UTF-8").newDecoder().decode(buffer).toString();
            System.out.println("receive client message: " + receiveMsg + " from " + channel.getRemoteAddress());
        }
    }

    /**
     * 向客戶端傳送響應訊息
     * @param channel
     * @throws IOException
     */
    private void sayHello(SocketChannel channel) throws IOException {
        buffer.clear();
        buffer.put(GREETING.getBytes());
        buffer.flip();
        channel.write(buffer);
    }

    /**
     * 註冊客戶端連線到選擇器上
     * @param selector
     * @param channel
     * @param opRead
     * @throws IOException
     */
    private void registerChannel(Selector selector, SocketChannel channel, int opRead) throws IOException {
        if (channel == null){
            return;
        }
        // 設為非阻塞模式
        channel.configureBlocking(false);
        // 註冊該channel到選擇器上
        channel.register(selector,opRead);
    }

}

通道執行緒

package com.rhwayfun.patchwork.nio.selector;

import java.io.IOException;
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;

/**
 * @author: rhwayfun
 * @since: 2016-05-28
 */
public class SelectorThread extends  Thread{

    private Selector selector;

    public SelectorThread(Selector selector) {
        this.selector = selector;
    }

    @Override
    public void run() {
        try {
            // 獲取Selector註冊的通道數
            int n = selector.select();
            while (n > 0){
                // selector.selectedKeys()可以獲取每個註冊通道的key
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()){
                    SelectionKey key = iterator.next();
                    if (key.isReadable()){
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        channel.read(buffer);
                        buffer.flip();
                        String receiveMsg = Charset.forName("UTF-8").newDecoder().decode(buffer).toString();
                        System.out.println("receive server message: " + receiveMsg + " from " + channel.getRemoteAddress());
                        key.interestOps(SelectionKey.OP_READ);
                    }
                    // 處理下一個事件
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上的程式碼演示如何使用NIO的相關API建立TCP伺服器，把上面的程式碼理解到位，對NIO的API就掌握的差不多了。其實，在NIO程式設計中，一個重要的思想是非阻塞模式，選擇器就是這種思想的體現，體會Selector在通道監聽有助於理解非阻塞模式的應用場景。

小結

這樣，我們通過實際的程式碼演示瞭如何使用NIO的相關API實現一個簡單的TCP伺服器，關鍵在於理解NIO模型的原理，非阻塞模式是NIO的思想核心。

相關推薦

Java NIO系列4：通道和選擇器

前言 今天加班回來，終於有時間繼續更新NIO的文章了。在前一篇文章我們講解了緩衝區的知識，並通過程式碼演示瞭如何使用緩衝區的API完成一些操作。這裡要講的通道於緩衝區關係密切，簡單來說，緩衝區是填充資料的載體，而通道則可以理解為傳輸資料的載體。回憶在TCP/I

java nio學習：緩衝區、通道和選擇器

java nio中引入了緩衝區，緩衝區中的資料可以寫入通道，也可以從通道中讀取資料到緩衝區。nio中的緩衝區就是對陣列的簡單封裝，緩衝區有讀模式和寫模式，緩衝區的屬性有容量（capacity）、限制(limit)、位置(position)，容量表示陣列的大小，限制表示第一個

夯實Java基礎系列4：一文了解final關鍵字的特性、使用方法，以及實現原理

目錄 final使用 final變數 final修飾基本資料型別變數和引用 final類 final關鍵字的知識點 final關鍵字的最佳實踐 final的用法 關於空白final final記憶體分配 使用final修飾方法會提高速度和效率嗎 使用final修飾變數會讓變數的值不能被改變嗎； 如何保

Java基礎系列4：抽象類與介面的前世今生

該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接著瞭解每個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，形成自己的知識框架。   1、抽象類：   當編寫一個類時，常常會為該類定義一些方法，這些方法用以描述該類的行為方式，那麼這些方法都

java nio系列教程(2)---channel(通道介紹)和使用

大家推薦個靠譜的公眾號程式設計師探索之路，大家一起加油 ​   package com.zzh.buffer; import com.google.common.collect.Lists; import org.junit.jupiter.api.Test; imp

Azure Stack技術深入淺出系列4： Azure Stack自定義虛擬機鏡像和Gallery Item

azurestack 雲計算 微軟 混合雲Azure Stack環境中服務的提供者或運營者從微軟變成了Azure Stack集成環境的運營者，通過Azure Stack的MarketPlace，我們可以根據用戶的特定需求，提供一些定制化的應用，獲得與公有雲不一樣的用戶體驗。本文將主要介紹如何在Azure St

Go基礎系列(4)：匯入包和初始化階段

import匯入包 搜尋路徑 import用於匯入包： import ( "fmt" "net/http" "mypkg" ) 編譯器會根據上面指定的相對路徑去搜索包然後匯入，這個相對路徑是從GOROOT或GOPATH(workspace)下的src下開始搜尋的。 假如go的安裝目錄為

java nio 系列教程(1)----buffer介紹和使用方法

大家推薦個靠譜的公眾號程式設計師探索之路，大家一起加油 ​   package com.zzh.buffer; import org.junit.jupiter.api.Test; import java.nio.ByteBuffer; /** * 一.緩衝區(b

Java NIO系列教程（五） 通道之間的資料傳輸

作者：Jakob Jenkov   譯者：郭蕾     校對：周泰 在Java NIO中，如果兩個通道中有一個是FileChannel，那你可以直接將資料從一個channel（譯者注：channel中文常譯作通道）傳輸到另外一個channel。 transferFrom() FileChan

Java NIO系列七之 AsynchronousFileChannel非同步檔案通道

Java7中新增了AsynchronousFileChannel作為nio的一部分。AsynchronousFileChannel使得資料可以進行非同步讀寫。下面將介紹一下AsynchronousFileChannel的使用。 建立AsynchronousFileChann

Java基礎系列16：使用JSONObject和JSONArray解析和構造json字串

轉自：https://www.zifangsky.cn/561.html 一 介紹 在Java開發中，我們通常需要進行XML文件或JSON字串的構造和解析。當然在Java Web開發中有一些第三方外掛是可以自動完成Java物件和json之間的轉換的，比

java io系列14：DataInputStream(資料輸入流)的認知、原始碼和示例

本章介紹DataInputStream。我們先對DataInputStream有個大致認識，然後再深入學習它的原始碼，最後通過示例加深對它的瞭解。 轉載請註明出處：http://www.cnblogs.com/skywang12345/p/io_14.html DataInputStream

CSS 從入門到放棄系列：CSS的選擇器和優先級

href css選擇器 數量 blue 比較 開頭 解決 ul li 選中 CSS的選擇器和優先級 CSS的N種選擇器 !important 其實這個玩意不算什麽選擇器，放在這只是為了突出這個選擇器優先級或者說權重的從高到低而已。。 內聯方式(行間樣式) <div

Java集合詳解4：HashMap和HashTable

var strong 大表 Java後端 們的 col keyword 創建 spl Java集合詳解4：HashMap和HashTable 今天我們來探索一下HashMap和HashTable機制與比較器的源碼。 具體代碼在我的GitHub中可以找到 https://gi

安卓儲存資料和檔案系列4：內容提供者（Content Provider）方式

內容提供者（Content Provider）是android的四大元件之一，重要性可想而知，一個程序的資料可以被另外一個程序訪問(在不同的apk之間可以訪問)，內容提供者可以跨應用，資料庫跨應用的使用場景：一個應用中提供資料給其他應用；允許使用者從一個應用中拷貝資料到另一

Java I/O系統學習系列一：File和RandomAccessFile

　　I/O系統即輸入/輸出系統，對於一門程式語言來說，建立一個好的輸入/輸出系統並非易事。因為不僅存在各種I/O源端和想要與之通訊的接收端(檔案、控制檯、網路連結等)，而且還需要支援多種不同方式的通訊(順序、隨機存取、緩衝、二進位制、按字元、按行、按字等)。 　　Java類庫的設計者通過建立大量的類來解決這個

Java I/O系統學習系列二：輸入和輸出

　　程式語言的I/O類庫中常使用流這個抽象概念，它代表任何有能力產出資料的資料來源物件或者是有能力接收資料的接收端物件。“流”遮蔽了實際的I/O裝置中處理資料的細節。 　　在這個系列的第一篇文章：<<Java I/O系統學習系列一：File和RandomAccessFil

夯實Java基礎系列5：Java檔案和Java包結構

目錄 Java中的包概念 包的作用 package 的目錄結構 設定 CLASSPATH 系統變數 常用jar包 java軟體包的型別 dt.jar rt.jar *.java檔案的奧祕 *.Java檔案簡介 為什麼一個java原始檔中只能有一個public類？ Main方法 外部類的訪問許可權

夯實Java基礎系列6：一文搞懂抽象類和介面，從基礎到面試題，揭祕其本質區別！

目錄 抽象類介紹 為什麼要用抽象類 一個抽象類小故事 一個抽象類小遊戲 介面介紹 介面與類相似點： 介面與類的區別： 介面特性 抽象類和介面的區別 介面的使用： 介面最佳實踐：設計模式中的工廠模式 介面與抽象類的本質區別是什麼？ 基本語法區別 設計思想區別 如何回答面試題：介面和抽象類的區別?

夯實Java基礎系列7：一文讀懂Java 程式碼塊和執行順序

目錄 Java中的構造方法 構造方法簡介 構造方法例項 例 1 例 2 Java中的幾種構造方法詳解 普通構造方法 預設構造方法 過載構造方法 java子類構造方法呼叫父類構造方法 Java中的程式碼塊簡介 Java程式碼塊使用 區域性程式碼塊 構造程式碼塊 靜態程式碼塊 Java程式碼塊、