Java NIO

NIO概述
- NIO與傳統 IO的區別
- 通道(Channel)
- - 直接與非直接緩沖區
- 通道& 緩沖區(Buffer)
NIO非阻塞式網路通信
- 阻塞式例子
- 非阻塞式
管道(Pipe)

NIO概述

Java NIO(New IO, Non-Blocking IO)是從 Java 1.4開始引入的全新的 IO. 特點是同步非阻塞, 面向緩沖區的

NIO與傳統 IO的區別

IO	NIO
面向流(Stream Oriented)單向的	面向緩沖區(Buffer Oriented)雙向的
阻塞IO(Blocking IO)	非阻塞IO(Non Blocking IO)
-	選擇器(Selectors)

*傳統 IO操作是 DMA(Direct Memory Access, 直接存盤器訪問;特點是操作時需往 CPU請求獲取權限)負責 IO介面與記憶體的互動. 而 NIO是通過 Channel與記憶體互動, 相比 DMA方式 Channel方式是獨立的, 因此性能略高

通道(Channel)

NIO的 Channel類似于傳統的“流”, 但它本身是不能直接訪問資料, 而只負責傳輸, 資料的存取是使用了緩沖區(Buffer)

通道的主要實作類
(-) FileChannel: 讀寫檔案的通道
(-) SocketChannel: 通過 TCP連接, 讀寫網路資料的通道
(-) ServerSocketChannel: 監聽 TCP連接, 為每一個連接都會創建一個 SocketChannel
(-) DatagramChannel: 通過 UDP連接, 讀寫網路資料的通道
獲取通道

支持通道的類, 可通過 getChannel()方法獲取通道
(1-1) 本地 IO:
(-) FileInputStream/FileOutputStream
(-) RandomAccessFile
(1-2) 網路 IO:
(-) Socket
(-) ServerSocket
(-) DatagramSocket
* 其它: 可以通過 Files類的靜態方法 newByteChannel()獲取位元組通道. 或可以通過通道的靜態方法 open()打開并回傳指定通道

通道之間的資料傳輸
(-) inFileChannel.transferTo(long position, long count, WritableByteChannel target): 從源(inFileChannel)傳輸到 target
(-) outFileChannel.transferFrom(ReadableByteChannel src, long position, long count): 從(src)源傳輸到 outFileChannel
分散(Scatter)& 聚集(Gather)
(-) 分散讀取(Scattering Reads): 將通道中的資料分散到多個緩沖區中. 注: 按斬訓沖區的順序依次填滿 Buffer
(-) 聚集寫入(Gathering Writes): 將多個 Buffer中的資料“聚集”到一個 Channel. 注: 按斬訓沖區的順序寫入, 從 position到 limit之間的資料到 Channel
字符集(Charset)
編碼(CharsetEncoder): 字串 -> 位元組陣列
解碼(CharsetDecoder): 位元組陣列 -> 字串

在這里插入圖片描述

FileChannel的常用方法:

int read(ByteBuffer dst)從 Channel中讀取資料到 dst
long read(ByteBuffer[] dsts)將 Channel中的資料“分散”存到 dsts
int write(ByteBuffer src)將 ByteBuffer中的資料寫入到 Channel
long write(ByteBuffer[] srcs)將 ByteBuffer[]中的資料“聚集”寫入到 Channel
long position()回傳此通道的檔案位置
FileChannel position(long p)設定此通道的檔案位置
long size()回傳此通道的檔案的當前大小
FileChannel truncate(long s)將通道中的檔案截斷為 s個位元組
void force(boolean metaData)將通道中還未寫入到磁盤的資料, 強制寫完

本地 Channel使用例子


# 利用通道完成檔案的復制(非直接緩沖區)
public class TestChannel {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("E:/1.ico");
        FileOutputStream fos = new FileOutputStream("E:/2.ico");
        FileChannel inChannel = fis.getChannel();
        FileChannel outChannel = fos.getChannel();
        // 分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 從 inChannel中讀取資料到 buf中
        while(inChannel.read(buf) != -1) {
			// 切換讀取模式
            buf.flip();
			// 將 buf中的資料寫入到 outChannel中
            outChannel.write(buf);
			// 清慷訓沖區
            buf.clear(); 
        }

        outChannel.close();
        inChannel.close();
        fos.close();
        fis.close();
    }
}

# 通過記憶體映射檔案復制(直接緩沖區)
public class TestChannel {
    public static void main(String[] args) throws IOException {
		FileChannel inChannel = FileChannel.open(Paths.get("E:/1.ico"), StandardOpenOption.READ);
		FileChannel outChannel = FileChannel.open(Paths.get("E:/2.ico"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
		// 記憶體映射檔案
		MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
		MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
		// 直接對緩沖區進行資料的讀寫操作
		byte[] dst = new byte[inMappedBuf.limit()];
		// 從 inMappedBuf中讀取位元組資料到 dst中
		inMappedBuf.get(dst);
		// 將 dst中的位元組資料寫入到 outMappedBuf中
		outMappedBuf.put(dst);

		inChannel.close();
		outChannel.close();
    }
}

# 通道之間的資料傳輸(直接緩沖區)
public class TestChannel {
    public static void main(String[] args) throws IOException {
        FileChannel inChannel = FileChannel.open(Paths.get("E:/1.ico"), StandardOpenOption.READ);
        FileChannel outChannel = FileChannel.open(Paths.get("E:/2.ico"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
		// 從源(inFileChannel)傳輸到 target
        inChannel.transferTo(0, inChannel.size(), outChannel);
		// 從(src)源傳輸到 outFileChannel
        outChannel.transferFrom(inChannel, 0, inChannel.size());

        inChannel.close();
        outChannel.close();
    }
}

# 分散和聚集
public class TestChannel {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("E:/1.sql", "rw");
        // 獲取通道
        FileChannel channel1 = raf1.getChannel();
        // 分配指定大小的緩沖區
        ByteBuffer buf1 = ByteBuffer.allocate(100);
        ByteBuffer buf2 = ByteBuffer.allocate(1024);
        // 分散讀取
        ByteBuffer[] bufs = {buf1, buf2};
		// 將 channel1中的資料分散讀取到 bufs中
        channel1.read(bufs);
        for (ByteBuffer byteBuffer: bufs) {
			// 切換讀取模式
            byteBuffer.flip();
        }
        System.out.println("buf1: " + new String(bufs[0].array(), 0, bufs[0].limit()));
        System.out.println("buf2: " + new String(bufs[1].array(), 0, bufs[1].limit()));
        // 聚集寫入
        RandomAccessFile raf2 = new RandomAccessFile("E:/2.sql", "rw");
        FileChannel channel2 = raf2.getChannel();
		// 將 bufs中的資料聚集寫入到 channel2中
        channel2.write(bufs);

        channel1.close();
        channel2.close();
		raf1.close();
		raf2.close();
    }
}

# 字符集
public class TestChannel {
    public static void main(String[] args) throws IOException {
        // 指定編碼
        Charset cs1 = Charset.forName("GBK");
        // 獲取編碼器
        CharsetEncoder encoder = cs1.newEncoder();
        // 獲取解碼器
        CharsetDecoder decoder = cs1.newDecoder();
        // 分配指定大小的非直接緩沖區
        CharBuffer buf1 = CharBuffer.allocate(1024);
        buf1.put("全abc12");
        // 切換讀取資料模式
        buf1.flip();
        // 編碼
        ByteBuffer buf2 = encoder.encode(buf1);
        for (int i = 0; i < 6; i++) {
            System.out.println(buf2.get());
        }
        // --> -56
        // --> -85
        // --> 97
        // --> 98
        // --> 99
        // --> 49
        // 切換讀取資料模式, 并重新配置 position
        buf2.flip();
        // 解碼
        CharBuffer buf3 = decoder.decode(buf2);
        System.out.println(buf3.toString()); // --> 全abc1

        System.out.println("-----");

        Charset cs2 = Charset.forName("GBK");
        // 切換讀取資料模式, 并重新配置 position
        buf2.flip();
        CharBuffer buf4 = cs2.decode(buf2);
        System.out.println(buf4.toString());
    }
}

直接與非直接緩沖區

執行程序:
(-) 非直接: 當程式從磁盤讀取資料時, 會首先將資料復制到物理記憶體中, 再將資料復制到 JVM的記憶體中后便可取到資料
(-) 直接: 在物理記憶體中建立一個緩沖區, 省略了復制到 JVM的步驟. 因此性能優于非直接緩沖區
分配緩沖區:
(-) 非直接: 通常是通過 allocate()方法來分配緩沖區, 將緩沖區建立在 JVM的記憶體中
(-) 直接: 可以通過 allocateDirect()指定緩沖區, FileChannel.map()記憶體映射檔案或 FileChannel.transferTo()和 FileChannel.transferFrom()通道之間的資料傳輸等, 將緩沖區建立在物理記憶體中
通過 isDirect()方法來判斷是否為直接緩沖區
* 雖然直接緩沖區性能好, 不過使用時, 有一定安全隱患及不被 GC自動回收的問題. 因此建議只用于, 保存長時間持久的基礎資訊

在這里插入圖片描述

通道& 緩沖區(Buffer)

NIO的 Buffer是用于與通道進行互動的, 從通道將資料讀入到緩沖區, 從緩沖區寫入通道的

常用子類
(-) ByteBuffer, CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer, DoubleBuffer
基本屬性
(-) capacity: Buffer的最大容量. capacity不能為負, 且創建后不能更改
(-) limit: 第一個不應該讀取或寫入的資料索引. 即位于 limit后的資料不可讀寫. 且不能大于 capacity
(-) position: 下一個要讀取或寫入的資料索引. position不能為負, 且不能大于 limit
(-) mark& reset: mark是一個索引, 通過 Buffer的 mark()方法指定 Buffer中特定的 position, 之后可以通過呼叫 reset()方法, 將 position轉到以前設定的 mark所在的位置
(-) * mark, position, limit, capacity遵守以下不變式: 0 <= mark <= position <= limit <= capacity

在這里插入圖片描述

Buffer的常用方法:

Buffer allocate(int capacity)分配非直接緩沖區
Buffer allocateDirect(int capacity)分配直接緩沖區
Buffer clear()清慷訓沖區, 并回傳對緩沖區的參考. 但清空后資料依然存在, 只不過資料狀態是被遺忘的狀態
Buffer flip()將緩沖區的界限設定為當前位置, 并將當前 position設定為0；切換為讀模式
int capacity()回傳 Buffer的 capacity大小
boolean hasRemaining()判斷緩沖區中是否還有元素
int limit()回傳 Buffer的 limit(界限)的位置
Buffer limit(int n)將設定緩沖區界限為 n, 并回傳一個具有新 limit的緩沖區物件
int position()回傳緩沖區的當前 position
Buffer position(int n)設定緩沖區的當前位置為 n, 并回傳修改后的 Buffer物件
int remaining()回傳 position和 limit之間的元素個數
Buffer mark()為指定 position設定標記
Buffer reset()將 position設定為 mark所在的位置；丟棄 mark位置之后的資料, 重新從 mark位置開始寫入(注: mark必須為已設定)
Buffer rewind()將 position設為 0, 取消 mark設定; 可以重復讀資料

緩沖區的資料操作:
獲取 Buffer中的資料:
get(): 讀取單個位元組
get(byte[] dst): 批量讀取多個位元組到 dst中
get(int index): 讀取指定索引位置的位元組(不會移動 position)
放入資料到 Buffer中:
put(byte b): 將給定單個位元組寫入緩沖區的當前位置
put(byte[] src): 將 src中的位元組寫入緩沖區的當前位置
put(int index, byte b): 將指定位元組寫入緩沖區的索引位置(不會移動 position)

Buffer使用例子


public class TestBuffer {
    public static void main(String[] args) {
        String str = "abcde";
        // 1. 分配指定大小的非直接緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        System.out.println(buf.capacity()); // --> 1024
        System.out.println("----- allocate() -----");
        System.out.println(buf.position()); // --> 0
        System.out.println(buf.limit()); // --> 1024
        // 2. 存入資料到緩沖區中
        buf.put(str.getBytes());
        System.out.println("----- put() -----");
        System.out.println(buf.position()); // --> 5
        System.out.println(buf.limit()); // --> 1024
        // 3. 切換讀取資料模式, 并重新配置 position
        buf.flip();
        System.out.println("----- flip() -----");
        System.out.println(buf.position()); // --> 0
        System.out.println(buf.limit()); // --> 5
        // 4. 讀取緩沖區中的資料
        byte[] dst = new byte[buf.limit()];
        // 4.1 將 buf中的資料輸入到 dst, 并重新配置 position
        buf.get(dst);
        System.out.println(new String(dst, 0, dst.length)); // --> abcde
        System.out.println("----- get() -----");
        System.out.println(buf.position()); // --> 5
        System.out.println(buf.limit()); // --> 5
        // 5. 可重復讀, 將 position設為 0, 并取消 mark設定
        buf.rewind();
        System.out.println("----- rewind() -----");
        System.out.println(buf.position()); // --> 0
        System.out.println(buf.limit()); // --> 5
        // 6. 清慷訓沖區. 但是緩沖區中的資料依然存在，但是處于“被遺忘”狀態
        buf.clear();
        System.out.println("----- clear() -----");
        System.out.println(buf.position()); // --> 0
        System.out.println(buf.limit()); // --> 1024
        // 6.1 資料狀態為被遺忘, 但依然可以輸出
        System.out.println((char) buf.get()); // --> a

        // 是否為直接緩沖區
        System.out.println("----- isDirect() -----");
        System.out.println(buf.isDirect()); // --> false
    }
}

public class TestBuffer {
    public static void main(String[] args) {
        String str = "abcde";
        // 分配指定大小的非直接緩沖區
        ByteBuffer buf = ByteBuffer.allocate(5);
        // 存入資料到緩沖區中
        buf.put(str.getBytes());
        // 切換讀取資料模式, 并重新配置 position
        buf.flip();
        byte[] dst2 = new byte[buf.limit()];
        buf.get(dst2, 0, 2);
        System.out.println("----- flip() -----");
        System.out.println(new String(dst2, 0, 2)); // --> ab
        System.out.println(buf.position()); // --> 2
        // 標記
        buf.mark(); // 標記 position = 2
        buf.get(dst2, 2, 3);
        System.out.println(new String(dst2, 2, 2)); // --> cd
        System.out.println(buf.position()); // --> 5
        System.out.println("----- hasRemaining() -----");
        System.out.println(buf.hasRemaining()); // --> false
        // 恢復到 mark的位置
        buf.reset();
        System.out.println("----- reset() -----");
        System.out.println(buf.position()); // --> 2
        // 判斷緩沖區中是否還有剩余資料
        if(buf.hasRemaining()){
            // 獲取緩沖區中可以操作的數量
            System.out.println("----- remaining() -----");
            System.out.println(buf.remaining()); // --> 3
        }
    }
}

NIO非阻塞式網路通信

阻塞與非阻塞

阻塞式(IO): 通過傳統 IO處理流時, 指定執行緒會被阻塞. 也就是說, 當使用傳統的 IO構建網路通信時, 服務器端會為每個客戶端, 開辟獨立的執行緒來維持連接, 由此引起, 性能急劇下降
非阻塞式(NIO): 在通道連接的狀態下, 若沒有資料可用時, 該執行緒可以進行其它任務. 如處理其它通道上的 IO, 也就是說, 一個執行緒可以管理多個輸入輸出通道. 因此, 區別于阻塞式, 通過非阻塞式實作的網路通信服務器, 可以將有限的執行緒(性能)更有效的利用來降低性能上的成本, 由此, 同步更多的客戶端

阻塞式例子

通過 Channel& Buffer, 傳輸檔案


public class NIOBlockingSocketServer {
    public static void main(String[] args) throws IOException {
        // 1. 獲取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        // 2. 系結連接
        ssChannel.bind(new InetSocketAddress(9898));
        // 3. 獲取本地檔案通道, 寫入模式(檔案不存在, 則創建)
        FileChannel outChannel = FileChannel.open(Paths.get("C:\\Users\\Shawn Jeon\\Pictures\\2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
        // 4. 獲取客戶端連接的通道
        SocketChannel sChannel = ssChannel.accept();
        // 5. 分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 6. 從 sChannel(客戶端通道)接收資料, 并保存到 buf
        while (sChannel.read(buf) != -1) {
            // 切換讀取模式
            buf.flip();
            // 往 outChannel通道(本地檔案), 寫入資料
            outChannel.write(buf);
            // 清慷訓沖區
            buf.clear();
        }

        // 反饋資訊到客戶端
        buf.put("服務端接收資料成功".getBytes());
        // 切換讀取模式
        buf.flip();
        // 往 sChannel通道(客戶端), 發送資料
        sChannel.write(buf);

        // 7. 關閉通道
        sChannel.close();
        outChannel.close();
        ssChannel.close();
    }
}

public class NIOBlockingSocketClient {
    public static void main(String[] args) throws IOException {
        // 1. 獲取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        // 2. 獲取本地檔案通道, 讀取模式
        FileChannel inChannel = FileChannel.open(Paths.get("C:\\Users\\Shawn Jeon\\Pictures\\1.jpg"), StandardOpenOption.READ);
        // 3. 分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 4. 從 inChannel讀取資料, 并保存到 buf
        while (inChannel.read(buf) != -1) {
            // 切換讀取模式
            buf.flip();
            // 往 sChannel通道(服務器端), 寫入資料
            sChannel.write(buf);
            // 清慷訓沖區
            buf.clear();
        }

        // 資料發送完畢, 不再發送更多資料
        sChannel.shutdownOutput();

        // 接收服務器端的反饋
        int len = 0;
        // 從 sChannel(服務器端通道)接收資料, 并保存到 buf
        while ((len = sChannel.read(buf)) != -1) {
            // 切換讀取模式
            buf.flip();
            // 列印反饋內容
            System.out.println(new String(buf.array(), 0, len));
            // 清慷訓沖區
            buf.clear();
        }

        // 5. 關閉通道
        inChannel.close();
        sChannel.close();
    }
}

非阻塞式

Selector(選擇器)

Selector是 Channel的多路復用器, NIO將所有的 Channel都注冊到 Selector上, 來監控各個 Channel的 IO狀態, 使一個執行緒管理多個 Channel

創建& 注冊通道

創建選擇器 Selector ServerSocketChannel::open()
向選擇器注冊通道 SelectionKey SelectableChannel.register(Selector sel, int ops); 注冊通道時, 可以通過引數 ops指定事件
(-) 讀 SelectionKey.OP_READ = 1 << 0 = 1
(-) 寫 SelectionKey.OP_WRITE = 1 << 2 = 4
(-) 連接 SelectionKey.OP_CONNECT = 1 << 3 = 8
(-) 接收 SelectionKey.OP_ACCEPT = 1 << 4 = 16
* 若監聽多個事件, 則可以使用"位或"運算子例 int interestSet = SelectionKey.OP_READ| SelectionKey.OP_WRITE;

SelectionKey常用方法描述:
int interestOps() 獲取選擇器中, 指定選擇器鍵的事件集
int readyOps() 獲取已就緒的操作集
SelectableChannel channel() 獲取已注冊的通道
Selector selector() 回傳創建此鍵的選擇器
boolean isReadable() 判斷指定選擇器鍵的 Channal的讀事件是否就緒
boolean isWritable() 判斷指定選擇器鍵的 Channal的寫事件是否就緒
boolean isConnectable() 判斷指定選擇器鍵的 Channal的連接事件是否就緒
boolean isAcceptable() 判斷指定選擇器鍵的 Channal的接收事件是否就緒
Selector方法描述:
Selector open() 打開一個選擇器
boolean isOpen() 判斷當前選擇器是否已開啟
Set keys() 回傳當前選擇器關聯的已注冊的 SelectionKey集合
Set selectedKeys() 回傳當前選擇器中已被選定(就緒)的 SelectionKey集合, 每個鍵都關聯一個已就緒的(至少含一種操作的通道)
int select() 回傳當前選擇器中的就緒通道數量, 如選擇器中沒有"就緒通道", 則阻塞執行緒, 直到有就緒的通道
int select(long timeout) 可以設定阻塞的超時時間(毫秒)
int selectNow() 回傳當前選擇器中的就緒通道數量, 如選擇器中沒有"就緒通道", 將立即回傳0, 而不阻塞執行緒
Selector wakeup() 使阻塞中的 select()方法立即回傳
void close() 關閉當前選擇器

TCP非阻塞式例子


public class NIONonBlockingSocketServer {
    public static void main(String[] args) throws IOException {
        // 1. 獲取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        // 2. 切換非阻塞模式
        ssChannel.configureBlocking(false);
        // 3. 系結連接
        ssChannel.bind(new InetSocketAddress(9898));
        // 4. 獲取選擇器
        Selector selector = Selector.open();
        // 5. 將通道注冊到選擇器上, 并且指定“監聽接收事件”
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        // 6. 輪詢式的獲取選擇器上已經“準備就緒”的事件
        while (selector.select() > 0) {
            // 7. 獲取當前選擇器中所有注冊的“選擇鍵(已就緒的監聽事件)”
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                // 8. 獲取準備“就緒”的是事件
                SelectionKey sk = it.next();
                // 9. 判斷具體是什么事件準備就緒
                if (sk.isAcceptable()) {
                    // 10. 若“接收就緒”, 獲取客戶端連接
                    SocketChannel sChannel = ssChannel.accept();
                    // 11. 切換非阻塞模式
                    sChannel.configureBlocking(false);
                    // 12. 將該通道注冊到選擇器上
                    sChannel.register(selector, SelectionKey.OP_READ);
                } else if (sk.isReadable()) { // 判斷選定的通道是否準備“就緒”, 用于讀取“接收到的資料“
                    // 13. 獲取當前選擇器上“讀就緒”狀態的通道
                    SocketChannel sChannel = (SocketChannel) sk.channel();
                    // 14. 分配指定大小的緩沖區
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    // 15. 從 sChannel(客戶端通道)接收資料, 并保存到 buf
                    int len = 0;
                    while ((len = sChannel.read(buf)) > 0 ) {
                        // 切換讀取模式
                        buf.flip();
                        // 列印內容
                        System.out.println(new String(buf.array(), 0, len));
                        // 清慷訓沖區
                        buf.clear();
                    }
                }
                // 16. 取消選擇鍵 SelectionKey
                it.remove();
            }
        }
    }
}

public class NIONonBlockingSocketClient {
    public static void main(String[] args) throws IOException {
        // 1. 獲取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
        // 2. 切換非阻塞模式
        sChannel.configureBlocking(false);
        // 3. 分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 4. 寫入資料到服務端
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            String str = scan.next();
            buf.put((str + " " + new Date().toString()).getBytes());
            // 切換讀取模式
            buf.flip();
            // 往 sChannel通道(服務器端), 寫入資料
            sChannel.write(buf);
            // 清慷訓沖區
            buf.clear();
        }
        // 5. 關閉通道
        sChannel.close();
    }
}

UDP非阻塞式例子


public class NonBlockingNIODatagramReceive {
    public static void main(String[] args) throws IOException {
        // 1. 獲取通道
        DatagramChannel dc = DatagramChannel.open();
        // 2. 切換非阻塞模式
        dc.configureBlocking(false);
        // 3. 給當前通道系結埠
        dc.bind(new InetSocketAddress(9898));
        // 4. 獲取選擇器
        Selector selector = Selector.open();
        // 5. 將該通道注冊到選擇器上
        dc.register(selector, SelectionKey.OP_READ);
        // 6. 輪詢式的獲取選擇器上已經“準備就緒”的事件
        while (selector.select() > 0) {
            // 7. 獲取當前選擇器中所有注冊的“選擇鍵(已就緒的監聽事件)”
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                // 8. 獲取準備“就緒”的是事件
                SelectionKey sk = it.next();
                // 判斷選定的通道是否準備“就緒”, 用于讀取“接收到的資料“
                if (sk.isReadable()) {
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    // 從 DatagramChannel接收資料, 并保存到 buf
                    dc.receive(buf);
                    // 切換讀取模式
                    buf.flip();
                    // 列印內容
                    System.out.println(new String(buf.array(), 0, buf.limit()));
                    // 清慷訓沖區
                    buf.clear();
                }
            }
            // 9. 取消選擇鍵 SelectionKey
            it.remove();
        }
    }
}

public class NonBlockingNIODatagramSend {
    public static void main(String[] args) throws IOException {
        // 1. 獲取通道
        DatagramChannel dc = DatagramChannel.open();
        // 2. 切換非阻塞模式
        dc.configureBlocking(false);
        // 3. 分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 4. 寫入資料到服務端
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            String str = scan.next();
            buf.put((str + " " + new Date().toString()).getBytes());
            // 切換讀取模式
            buf.flip();
            // 往指定 UDP接收端的地址, 發送資料
            dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
            // 清慷訓沖區
            buf.clear();
        }
        // 5. 關閉通道
        dc.close();
    }
}

管道(Pipe)

Java NIO在 JVM內不同執行緒之間通過管道單向傳輸資料. 通過 pipe.source()通道讀取資料, 再通過 pipe.sink()通道寫入并傳輸資料

在這里插入圖片描述


public class PipeTest {
    public static void main(String[] args) throws IOException {
        // 獲取管道
        Pipe pipe = Pipe.open();
        // 分配指定大小的緩沖區
        ByteBuffer buf = ByteBuffer.allocate(1024);

        // 獲取 sink管道，用來傳送資料
        Pipe.SinkChannel sinkChannel = pipe.sink();
        buf.put("通過管道單向發送資料".getBytes());
        buf.flip();
        // 傳送資料
        sinkChannel.write(buf);

        // 獲取 source管道, 用來接收管道資料
        Pipe.SourceChannel sourceChannel = pipe.source();
        buf.flip();
        // 讀取資料
        int len = sourceChannel.read(buf);
        // 列印內容
        System.out.println(new String(buf.array(), 0, len));

        // 關閉通道
        sourceChannel.close();
        sinkChannel.close();
    }
}

如果您覺得有幫助，歡迎點贊哦 ~ 謝謝!!

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/262538.html

標籤：java

上一篇：maven(1)

下一篇：深入理解Java虛擬機（一）

Java-NIO

Java NIO

NIO概述

NIO與傳統 IO的區別

通道(Channel)

直接與非直接緩沖區

通道& 緩沖區(Buffer)

NIO非阻塞式網路通信

阻塞式例子

非阻塞式

管道(Pipe)