NIO基礎（非阻塞式IO ）
1.三大元件
1.1.Channel & Buffer
Channel有一點類似於 stream，它就是讀寫資料的雙向通道（Java IO流中的OutputStream和InputStream都是單向通道），可以從 channel將資料讀入 buffer，也可以將buffer 的資料寫入 channel，而之前的 stream 要麼是輸入，要麼是輸出，channel比 stream 更為底層
常見的 Channel 有
- FileChannel（檔案）
- DatagramChannel（UDP）
- SocketChannel（TCP - 伺服器 /客戶端）
- ServerSocketChannel（TCP - 專用伺服器）
Buffer 則用來緩衝讀寫資料，常見的 Buffer 有
ByteBuffer（常用 抽象類）- MappedByteBuffer
- DirectByteBuffer
- HeapByteBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
1.2 Selector
selector 單從字面不好理解，需要結合伺服器的設計演化來理解它的用途
多執行緒版設計
客戶端的每一個連線都是圖中的一個socket連線
把thread類比成服務員，socket類比成顧客，如果有1000個顧客，那麼就需要有1000個服務員，這明顯是不合理的
⚠️多執行緒版缺點
- 記憶體佔用高（建立執行緒）
- 執行緒上下文切換成本高
- 只適合連線數少的場景
執行緒池版設計
在阻塞模式下，thread必須等socket1全部操作執行完成後，才能去服務socket2
⚠️執行緒池子版缺點
- 阻塞模式下，執行緒僅能處理一個 socket 連線
- 僅適短連線場景 （斷開，讓執行緒去處理別的連線）
Selector 版設計
selector 的作用就是配合一個執行緒來管理多個 channel，獲取這些 channel 上發生的事件，這些 channel 工作在非阻塞模式下，不會讓執行緒吊死在一個channel 上。適合連線數特別多，但流量低的場景(low traffic)
-
channel等同於之前的socket
-
selector相當於一個監視器，channel（顧客）的一舉一動都會被selector捕獲
呼叫 selector 的 select()會阻塞直到 channel發生了讀寫就緒事件，這些事件發生，select方法就會返回這些事件交給thread 來處理
2.ByteBuffer
2.1.ByteBuffer 正確使用姿勢
1.向 buffer 寫入資料，例如呼叫 channel.read(buffer)
2.呼叫 flip() 切換至讀模式
3.從 buffer 讀取資料，例如呼叫 buffer.get()
4.呼叫 clear() 或 compact() 切換至寫模式
5.重複 1~4 步驟
2.2 ByteBuffer 結構
- ByteBuffer 有以下重要屬性
- capacity（容量，不變)
- position（指標）
- limit（讀寫限制）
一開始
寫模式下，position 是寫入位置，limit 等於容量，下圖表示寫入了4個位元組後的狀態
flip 動作發生後，position 切換為讀取位置，limit 切換為讀取限制（如果是rewind，則Limit = Capacity）
讀取4個位元組後，狀態
clear 動作發生後，狀態
compact 方法，是把未讀完的部分向前壓縮，然後切換至寫模式
try (FileInputStream fis = new FileInputStream("data.txt");
FileChannel channel = fis.getChannel()) {
// 準備緩衝區
ByteBuffer buffer = ByteBuffer.allocate(13);
// 讀取資料到緩衝區
int bytesRead = channel.read(buffer);
while (bytesRead != -1) {
// 準備從緩衝區讀取資料 切換到讀模式
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear(); // 為下一次讀取清空緩衝區
bytesRead = channel.read(buffer);
}
} catch (IOException e) {
e.printStackTrace();
}
2.3 ByteBuffer 常見方法
分配空間
可以使用 allocate 方法為 ByteBuffer 分配空間，其它 buffer 類也有該方法
Bytebuffer buf = ByteBuffer.allocate(16);
向 buffer 寫入資料
有兩種辦法
- 呼叫 channel 的 read 方法
- 呼叫 buffer 自己的 put 方法
int readBytes = channel.read(buf);
和
buf.put((byte)127);
從 buffer 讀取資料
同樣有兩種辦法
- 呼叫 channel 的 write 方法
- 呼叫 buffer 自己的 get 方法
int writeBytes = channel.write(buf);
和
byte b = buf.get();
get 方法會讓 position 讀指標向後走，如果想重複讀取資料
- 可以呼叫 rewind 方法將 position 重新置為 0
- 或者呼叫 get(int i) 方法獲取索引 i 的內容，它不會移動讀指標
mark 和 reset
mark 是在讀取時，做一個標記，即使 position 改變，只要呼叫 reset 就能回到 mark 的位置
注意
rewind 和 flip 都會清除 mark 位置
字串與 ByteBuffer 互轉
public static void transfer2ByteBuffer1() {
buffer.put("hello".getBytes());
debugAll(buffer);
}
public static void transfer2ByteBuffer2() {
// 這種方式會自動切換到讀模式
ByteBuffer buffer = StandardCharsets.UTF_8.encode("hello");
debugAll(buffer);
}
public static void transfer2ByteBuffer3() {
// 這種方式會自動切換到讀模式
ByteBuffer buffer = ByteBuffer.wrap("hello".getBytes());
debugAll(buffer);
}
public static void transfer2String() {
ByteBuffer buffer = StandardCharsets.UTF_8.encode("hello");
String str = StandardCharsets.UTF_8.decode(buffer).toString();
System.out.println(str);
}
輸出
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| e4 bd a0 e5 a5 bd |...... |
+--------+-------------------------------------------------+----------------+
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| e4 bd a0 e5 a5 bd |...... |
+--------+-------------------------------------------------+----------------+
class java.nio.HeapCharBuffer
你好
⚠️ Buffer 的執行緒安全
Buffer 是非執行緒安全的
2.4 Scattering Reads
分散讀取，有一個文字檔案 3parts.txt
onetwothree
使用如下方式讀取，可以將資料填充至多個 buffer
try (RandomAccessFile file = new RandomAccessFile("helloword/3parts.txt", "rw")) {
FileChannel channel = file.getChannel();
ByteBuffer a = ByteBuffer.allocate(3);
ByteBuffer b = ByteBuffer.allocate(3);
ByteBuffer c = ByteBuffer.allocate(5);
channel.read(new ByteBuffer[]{a, b, c});
debugAll(a);
debugAll(b);
debugAll(c);
} catch (IOException e) {
e.printStackTrace();
}
結果
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 6f 6e 65 |one |
+--------+-------------------------------------------------+----------------+
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 74 77 6f |two |
+--------+-------------------------------------------------+----------------+
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 74 68 72 65 65 |three |
+--------+-------------------------------------------------+----------------+
2.5 Gathering Writes
使用如下方式寫入，可以將多個 buffer 的資料填充至 channel
ByteBuffer buffer1 = StandardCharsets.UTF_8.encode("hello");
ByteBuffer buffer2 = StandardCharsets.UTF_8.encode("world");
ByteBuffer buffer3 = StandardCharsets.UTF_8.encode("你好");
try (RandomAccessFile raf = new RandomAccessFile("words2.txt","rw");
FileChannel channel = raf.getChannel()) {
ByteBuffer[] buffers = {buffer1, buffer2, buffer3};
channel.write(buffers);
} catch (IOException e) {
e.printStackTrace();
}
2.6 練習
網路上有多條資料傳送給服務端，資料之間使用 \n 進行分隔
但由於某種原因這些資料在接收時，被進行了重新組合，例如原始資料有3條為
- Hello,world\n
- I'm zhangsan\n
- How are you?\n
變成了下面的兩個 byteBuffer (黏包，半包)
- Hello,world\nI'm zhangsan\nHo
- w are you?\n
現在要求你編寫程式，將錯亂的資料恢復成原始的按 \n 分隔的資料
public static void main(String[] args) {
ByteBuffer source = ByteBuffer.allocate(32);
source.put("Hello,world\nI'm zhangsan\nHo".getBytes());
spilt(source);
source.put("w are you?\n".getBytes());
spilt(source);
}
public static void spilt(ByteBuffer source) {
source.flip();
for (int i = 0; i < source.limit(); i++) {
// 找到一條完整訊息
if (source.get(i) == '\n') {
int length = i + 1 - source.position();
// 把這條完整訊息存入新的ByteBuffer
ByteBuffer target = ByteBuffer.allocate(length);
// 從source讀，向target寫
for (int j = 0; j < length; j++) {
target.put(source.get());
}
debugAll(target);
}
}
source.compact() ;
}
3. 檔案程式設計
3.1FileChannel
⚠️ FileChannel 工作模式
FileChannel 只能工作在阻塞模式下
獲取
不能直接開啟 FileChannel，必須透過 FileInputStream、FileOutputStream 或者 RandomAccessFile 來獲取 FileChannel，它們都有 getChannel 方法
- 透過 FileInputStream 獲取的 channel 只能讀
- 透過 FileOutputStream 獲取的 channel 只能寫
- 透過 RandomAccessFile 是否能讀寫根據構造 RandomAccessFile 時的讀寫模式決定
讀取
會從 channel 讀取資料填充 ByteBuffer，返回值表示讀到了多少位元組，-1 表示到達了檔案的末尾
int readBytes = channel.read(buffer);
寫入
寫入的正確姿勢如下， SocketChannel
ByteBuffer buffer = ...;
buffer.put(...); // 存入資料
buffer.flip(); // 切換讀模式
while(buffer.hasRemaining()) {
channel.write(buffer);
}
在 while 中呼叫 channel.write 是因為 write 方法並不能保證一次將 buffer 中的內容全部寫入 channel
關閉
channel 必須關閉，不過呼叫了 FileInputStream、FileOutputStream 或者 RandomAccessFile 的 close 方法會間接地呼叫 channel 的 close 方法
強制寫入
作業系統出於效能的考慮，會將資料快取，不是立刻寫入磁碟。可以呼叫 force(true) 方法將檔案內容和後設資料（檔案的許可權等資訊）立刻寫入磁碟
3.2 兩個 Channel 傳輸資料
String FROM = "helloword/data.txt";
String TO = "helloword/to.txt";
long start = System.nanoTime();
try (FileChannel from = new FileInputStream(FROM).getChannel();
FileChannel to = new FileOutputStream(TO).getChannel();
) {
from.transferTo(0, from.size(), to);
} catch (IOException e) {
e.printStackTrace();
}
long end = System.nanoTime();
System.out.println("transferTo 用時：" + (end - start) / 1000_000.0);
輸出
transferTo 用時：8.2011
超過 2g 大小的檔案傳輸
public class TestFileChannelTransferTo {
public static void main(String[] args) {
try (
FileChannel from = new FileInputStream("data.txt").getChannel();
FileChannel to = new FileOutputStream("to.txt").getChannel();
) {
// 效率高，底層會利用作業系統的零複製進行最佳化
long size = from.size();
// left 變數代表還剩餘多少位元組
for (long left = size; left > 0; ) {
System.out.println("position:" + (size - left) + " left:" + left);
left -= from.transferTo((size - left), left, to);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
實際傳輸一個超大檔案
position:0 left:7769948160
position:2147483647 left:5622464513
position:4294967294 left:3474980866
position:6442450941 left:1327497219
3.3 Path
jdk7 引入了 Path 和 Paths 類
- Path 用來表示檔案路徑
- Paths 是工具類，用來獲取 Path 例項
Path source = Paths.get("1.txt"); // 相對路徑 使用 user.dir 環境變數來定位 1.txt
Path source = Paths.get("d:\\1.txt"); // 絕對路徑 代表了 d:\1.txt
Path source = Paths.get("d:/1.txt"); // 絕對路徑 同樣代表了 d:\1.txt
Path projects = Paths.get("d:\\data", "projects"); // 代表了 d:\data\projects
.代表了當前路徑..代表了上一級路徑
例如目錄結構如下
d:
|- data
|- projects
|- a
|- b
程式碼
Path path = Paths.get("d:\\data\\projects\\a\\..\\b");
System.out.println(path);
System.out.println(path.normalize()); // 正常化路徑
會輸出
d:\data\projects\a\..\b
d:\data\projects\b
3.4 Files
檢查檔案是否存在
Path path = Paths.get("helloword/data.txt");
System.out.println(Files.exists(path));
建立一級目錄
Path path = Paths.get("helloword/d1");
Files.createDirectory(path);
- 如果目錄已存在，會拋異常 FileAlreadyExistsException
- 不能一次建立多級目錄，否則會拋異常 NoSuchFileException
建立多級目錄用
Path path = Paths.get("helloword/d1/d2");
Files.createDirectories(path);
複製檔案
Path source = Paths.get("helloword/data.txt");
Path target = Paths.get("helloword/target.txt"); // 複製的前提是不能有這個檔案
Files.copy(source, target);
- 如果檔案已存在，會拋異常 FileAlreadyExistsException
如果希望用 source 覆蓋掉 target，需要用 StandardCopyOption 來控制
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
移動檔案
Path source = Paths.get("helloword/data.txt");
Path target = Paths.get("helloword/data.txt");
Files.move(source, target, StandardCopyOption.ATOMIC_MOVE);
- StandardCopyOption.ATOMIC_MOVE 保證檔案移動的原子性
刪除檔案
Path target = Paths.get("helloword/target.txt");
Files.delete(target);
- 如果檔案不存在，會拋異常 NoSuchFileException
刪除目錄
Path target = Paths.get("helloword/d1");
Files.delete(target);
- 如果目錄還有內容，會拋異常 DirectoryNotEmptyException
遍歷目錄檔案
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Program Files\\Java\\jdk1.8.0_91");
AtomicInteger dirCount = new AtomicInteger();
AtomicInteger fileCount = new AtomicInteger();
Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
throws IOException {
System.out.println(dir);
dirCount.incrementAndGet();
return super.preVisitDirectory(dir, attrs);
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
System.out.println(file);
fileCount.incrementAndGet();
return super.visitFile(file, attrs);
}
});
System.out.println(dirCount); // 133
System.out.println(fileCount); // 1479
}
統計 jar 的數目
Path path = Paths.get("C:\\Program Files\\Java\\jdk1.8.0_91");
AtomicInteger fileCount = new AtomicInteger();
Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
if (file.toFile().getName().endsWith(".jar")) {
fileCount.incrementAndGet();
}
return super.visitFile(file, attrs);
}
});
System.out.println(fileCount); // 724
刪除多級目錄
Path path = Paths.get("d:\\a");
Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
Files.delete(file);
return super.visitFile(file, attrs);
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc)
throws IOException {
Files.delete(dir);
return super.postVisitDirectory(dir, exc);
}
});
⚠️ 刪除很危險
刪除是危險操作，確保要遞迴刪除的資料夾沒有重要內容
複製多級目錄
long start = System.currentTimeMillis();
String source = "D:\\Snipaste-1.16.2-x64";
String target = "D:\\Snipaste-1.16.2-x64aaa";
Files.walk(Paths.get(source)).forEach(path -> {
try {
String targetName = path.toString().replace(source, target);
// 是目錄
if (Files.isDirectory(path)) {
Files.createDirectory(Paths.get(targetName));
}
// 是普通檔案
else if (Files.isRegularFile(path)) {
Files.copy(path, Paths.get(targetName));
}
} catch (IOException e) {
e.printStackTrace();
}
});
long end = System.currentTimeMillis();
System.out.println(end - start);
4. 網路程式設計
4.1 非阻塞 vs 阻塞
阻塞
- 阻塞模式下，相關方法都會導致執行緒暫停
- ServerSocketChannel.accept 會在沒有連線建立時讓執行緒暫停
- SocketChannel.read 會在沒有資料可讀時讓執行緒暫停
- 阻塞的表現其實就是執行緒暫停了，暫停期間不會佔用 cpu，但執行緒相當於閒置
- 單執行緒下，阻塞方法之間相互影響，幾乎不能正常工作，需要多執行緒支援
- 但多執行緒下，有新的問題，體現在以下方面
- 32 位 jvm 一個執行緒 320k，64 位 jvm 一個執行緒 1024k，如果連線數過多，必然導致 OOM，並且執行緒太多，反而會因為頻繁上下文切換導致效能降低
- 可以採用執行緒池技術來減少執行緒數和執行緒上下文切換，但治標不治本，如果有很多連線建立，但長時間 inactive，會阻塞執行緒池中所有執行緒，因此不適合長連線，只適合短連線
伺服器端
// 使用 nio 來理解阻塞模式, 單執行緒
// 0. ByteBuffer
ByteBuffer buffer = ByteBuffer.allocate(16);
// 1. 建立了伺服器
ServerSocketChannel ssc = ServerSocketChannel.open();
// 2. 繫結監聽埠
ssc.bind(new InetSocketAddress(8080));
// 3. 連線集合
List<SocketChannel> channels = new ArrayList<>();
while (true) {
// 4. accept 建立與客戶端連線， SocketChannel 用來與客戶端之間通訊
log.debug("connecting...");
SocketChannel sc = ssc.accept(); // 阻塞方法，執行緒停止執行
log.debug("connected... {}", sc);
channels.add(sc);
for (SocketChannel channel : channels) {
// 5. 接收客戶端傳送的資料
log.debug("before read... {}", channel);
channel.read(buffer); // 阻塞方法，執行緒停止執行
buffer.flip();
debugRead(buffer);
buffer.clear();
log.debug("after read...{}", channel);
}
}
客戶端
SocketChannel sc = SocketChannel.open();
sc.connect(new InetSocketAddress("localhost", 8080));
System.out.println("waiting...");
非阻塞
- 非阻塞模式下，相關方法都會不會讓執行緒暫停
- 在 ServerSocketChannel.accept 在沒有連線建立時，會返回 null，繼續執行
- SocketChannel.read 在沒有資料可讀時，會返回 0，但執行緒不必阻塞，可以去執行其它 SocketChannel 的 read 或是去執行 ServerSocketChannel.accept
- 寫資料時，執行緒只是等待資料寫入 Channel 即可，無需等 Channel 透過網路把資料傳送出去
- 但非阻塞模式下，即使沒有連線建立，和可讀資料，執行緒仍然在不斷執行，白白浪費了 cpu
- 資料複製過程中，執行緒實際還是阻塞的（AIO 改進的地方）
伺服器端，客戶端程式碼不變
// 使用 nio 來理解非阻塞模式, 單執行緒
// 0. ByteBuffer
ByteBuffer buffer = ByteBuffer.allocate(16);
// 1. 建立了伺服器
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false); // 非阻塞模式
// 2. 繫結監聽埠
ssc.bind(new InetSocketAddress(8080));
// 3. 連線集合
List<SocketChannel> channels = new ArrayList<>();
while (true) {
// 4. accept 建立與客戶端連線， SocketChannel 用來與客戶端之間通訊
SocketChannel sc = ssc.accept(); // 非阻塞，執行緒還會繼續執行，如果沒有連線建立，但sc是null
if (sc != null) {
log.debug("connected... {}", sc);
sc.configureBlocking(false); // 非阻塞模式
channels.add(sc);
}
for (SocketChannel channel : channels) {
// 5. 接收客戶端傳送的資料
int read = channel.read(buffer);// 非阻塞，執行緒仍然會繼續執行，如果沒有讀到資料，read 返回 0
if (read > 0) {
buffer.flip();
debugRead(buffer);
buffer.clear();
log.debug("after read...{}", channel);
}
}
}
多路複用
單執行緒可以配合 Selector 完成對多個 Channel 可讀寫事件的監控，這稱之為多路複用
- 多路複用僅針對網路 IO、普通檔案 IO 沒法利用多路複用
- 如果不用 Selector 的非阻塞模式，執行緒大部分時間都在做無用功，而 Selector 能夠保證
- 有可連線事件時才去連線
- 有可讀事件才去讀取
- 有可寫事件才去寫入
- 限於網路傳輸能力，Channel 未必時時可寫，一旦 Channel 可寫，會觸發 Selector 的可寫事件
4.2 Selector
graph TD
subgraph selector 版
thread --> selector
selector --> c1(channel)
selector --> c2(channel)
selector --> c3(channel)
end
好處
- 一個執行緒配合 selector 就可以監控多個 channel 的事件，事件發生執行緒才去處理。避免非阻塞模式下所做無用功
- 讓這個執行緒能夠被充分利用
- 節約了執行緒的數量
- 減少了執行緒上下文切換
建立
Selector selector = Selector.open();
繫結 Channel 事件
也稱之為註冊事件，繫結的事件 selector 才會關心
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, 繫結事件);
- channel 必須工作在非阻塞模式
- FileChannel 沒有非阻塞模式，因此不能配合 selector 一起使用
- 繫結的事件型別可以有
- connect - 客戶端連線成功時觸發
- accept - 伺服器端成功接受連線時觸發
- read - 資料可讀入時觸發，有因為接收能力弱，資料暫不能讀入的情況
- write - 資料可寫出時觸發，有因為傳送能力弱，資料暫不能寫出的情況
監聽 Channel 事件
可以透過下面三種方法來監聽是否有事件發生，方法的返回值代表有多少 channel 發生了事件
方法1，阻塞直到繫結事件發生
int count = selector.select();
方法2，阻塞直到繫結事件發生，或是超時（時間單位為 ms）
int count = selector.select(long timeout);
方法3，不會阻塞，也就是不管有沒有事件，立刻返回，自己根據返回值檢查是否有事件
int count = selector.selectNow();
💡 select 何時不阻塞
- 事件發生時
- 客戶端發起連線請求，會觸發 accept 事件
- 客戶端傳送資料過來，客戶端正常、異常關閉時，都會觸發 read 事件，另外如果傳送的資料大於 buffer 緩衝區，會觸發多次讀取事件
- channel 可寫，會觸發 write 事件
- 在 linux 下 nio bug 發生時
- 呼叫 selector.wakeup()
- 呼叫 selector.close()
- selector 所線上程 interrupt
4.3 處理 accept 事件
客戶端程式碼為
public class Client {
public static void main(String[] args) {
try (Socket socket = new Socket("localhost", 8080)) {
System.out.println(socket);
socket.getOutputStream().write("world".getBytes());
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
}
伺服器端程式碼為
@Slf4j
public class ChannelDemo6 {
public static void main(String[] args) {
try (ServerSocketChannel channel = ServerSocketChannel.open()) {
channel.bind(new InetSocketAddress(8080));
System.out.println(channel);
Selector selector = Selector.open();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
int count = selector.select();
// int count = selector.selectNow();
log.debug("select count: {}", count);
// if(count <= 0) {
// continue;
// }
// 獲取所有事件
Set<SelectionKey> keys = selector.selectedKeys();
// 遍歷所有事件，逐一處理
Iterator<SelectionKey> iter = keys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
// 判斷事件型別
if (key.isAcceptable()) {
ServerSocketChannel c = (ServerSocketChannel) key.channel();
// 必須處理
SocketChannel sc = c.accept();
log.debug("{}", sc);
}
// 處理完畢，必須將事件移除
iter.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
💡 事件發生後能否不處理
事件發生後，要麼處理，要麼取消（cancel），不能什麼都不做，否則下次該事件仍會觸發，這是因為 nio 底層使用的是水平觸發
4.4 處理 read 事件
@Slf4j
public class ChannelDemo6 {
public static void main(String[] args) {
try (ServerSocketChannel channel = ServerSocketChannel.open()) {
channel.bind(new InetSocketAddress(8080));
System.out.println(channel);
Selector selector = Selector.open();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
int count = selector.select();
// int count = selector.selectNow();
log.debug("select count: {}", count);
// if(count <= 0) {
// continue;
// }
// 獲取所有事件
Set<SelectionKey> keys = selector.selectedKeys();
// 遍歷所有事件，逐一處理
Iterator<SelectionKey> iter = keys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
// 判斷事件型別
if (key.isAcceptable()) {
ServerSocketChannel c = (ServerSocketChannel) key.channel();
// 必須處理
SocketChannel sc = c.accept();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
log.debug("連線已建立: {}", sc);
} else if (key.isReadable()) {
SocketChannel sc = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(128);
int read = sc.read(buffer);
if(read == -1) {
key.cancel();
sc.close();
} else {
buffer.flip();
debug(buffer);
}
}
// 處理完畢，必須將事件移除
iter.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
開啟兩個客戶端，修改一下傳送文字，輸出
sun.nio.ch.ServerSocketChannelImpl[/0:0:0:0:0:0:0:0:8080]
21:16:39 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
21:16:39 [DEBUG] [main] c.i.n.ChannelDemo6 - 連線已建立: java.nio.channels.SocketChannel[connected local=/127.0.0.1:8080 remote=/127.0.0.1:60367]
21:16:39 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f |hello |
+--------+-------------------------------------------------+----------------+
21:16:59 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
21:16:59 [DEBUG] [main] c.i.n.ChannelDemo6 - 連線已建立: java.nio.channels.SocketChannel[connected local=/127.0.0.1:8080 remote=/127.0.0.1:60378]
21:16:59 [DEBUG] [main] c.i.n.ChannelDemo6 - select count: 1
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 77 6f 72 6c 64 |world |
+--------+-------------------------------------------------+----------------+
💡 為何要 iter.remove()
因為 select 在事件發生後，就會將相關的 key 放入 selectedKeys 集合，但不會在處理完後從 selectedKeys 集合中移除，需要我們自己編碼刪除。例如
- 第一次觸發了 ssckey 上的 accept 事件，沒有移除 ssckey
- 第二次觸發了 sckey 上的 read 事件，但這時 selectedKeys 中還有上次的 ssckey ，在處理時因為沒有真正的 serverSocket 連上了，就會導致空指標異常
💡 cancel 的作用
cancel 會取消註冊在 selector 上的 channel，並從 keys 集合中刪除 key 後續不會再監聽事件
⚠️ 不處理邊界的問題
以前有同學寫過這樣的程式碼，思考註釋中兩個問題，以 bio 為例，其實 nio 道理是一樣的
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket ss=new ServerSocket(9000);
while (true) {
Socket s = ss.accept();
InputStream in = s.getInputStream();
// 這裡這麼寫，有沒有問題
byte[] arr = new byte[4];
while(true) {
int read = in.read(arr);
// 這裡這麼寫，有沒有問題
if(read == -1) {
break;
}
System.out.println(new String(arr, 0, read));
}
}
}
}
客戶端
public class Client {
public static void main(String[] args) throws IOException {
Socket max = new Socket("localhost", 9000);
OutputStream out = max.getOutputStream();
out.write("hello".getBytes());
out.write("world".getBytes());
out.write("你好".getBytes());
max.close();
}
}
輸出
hell
owor
ld�
�好
為什麼？
處理訊息的邊界
- 一種思路是固定訊息長度，資料包大小一樣，伺服器按預定長度讀取，缺點是浪費頻寬
- 另一種思路是按分隔符拆分，缺點是效率低
- TLV 格式，即 Type 型別、Length 長度、Value 資料，型別和長度已知的情況下，就可以方便獲取訊息大小，分配合適的 buffer，缺點是 buffer 需要提前分配，如果內容過大，則影響 server 吞吐量
- Http 1.1 是 TLV 格式
- Http 2.0 是 LTV 格式
sequenceDiagram
participant c1 as 客戶端1
participant s as 伺服器
participant b1 as ByteBuffer1
participant b2 as ByteBuffer2
c1 ->> s: 傳送 01234567890abcdef3333\r
s ->> b1: 第一次 read 存入 01234567890abcdef
s ->> b2: 擴容
b1 ->> b2: 複製 01234567890abcdef
s ->> b2: 第二次 read 存入 3333\r
b2 ->> b2: 01234567890abcdef3333\r
伺服器端
private static void split(ByteBuffer source) {
source.flip();
for (int i = 0; i < source.limit(); i++) {
// 找到一條完整訊息
if (source.get(i) == '\n') {
int length = i + 1 - source.position();
// 把這條完整訊息存入新的 ByteBuffer
ByteBuffer target = ByteBuffer.allocate(length);
// 從 source 讀，向 target 寫
for (int j = 0; j < length; j++) {
target.put(source.get());
}
debugAll(target);
}
}
source.compact(); // 0123456789abcdef position 16 limit 16
}
public static void main(String[] args) throws IOException {
// 1. 建立 selector, 管理多個 channel
Selector selector = Selector.open();
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
// 2. 建立 selector 和 channel 的聯絡（註冊）
// SelectionKey 就是將來事件發生後，透過它可以知道事件和哪個channel的事件
SelectionKey sscKey = ssc.register(selector, 0, null);
// key 只關注 accept 事件
sscKey.interestOps(SelectionKey.OP_ACCEPT);
log.debug("sscKey:{}", sscKey);
ssc.bind(new InetSocketAddress(8080));
while (true) {
// 3. select 方法, 沒有事件發生，執行緒阻塞，有事件，執行緒才會恢復執行
// select 在事件未處理時，它不會阻塞, 事件發生後要麼處理，要麼取消，不能置之不理
selector.select();
// 4. 處理事件, selectedKeys 內部包含了所有發生的事件
Iterator<SelectionKey> iter = selector.selectedKeys().iterator(); // accept, read
while (iter.hasNext()) {
SelectionKey key = iter.next();
// 處理key 時，要從 selectedKeys 集合中刪除，否則下次處理就會有問題
iter.remove();
log.debug("key: {}", key);
// 5. 區分事件型別
if (key.isAcceptable()) { // 如果是 accept
ServerSocketChannel channel = (ServerSocketChannel) key.channel();
SocketChannel sc = channel.accept();
sc.configureBlocking(false);
ByteBuffer buffer = ByteBuffer.allocate(16); // attachment
// 將一個 byteBuffer 作為附件關聯到 selectionKey 上
SelectionKey scKey = sc.register(selector, 0, buffer);
scKey.interestOps(SelectionKey.OP_READ);
log.debug("{}", sc);
log.debug("scKey:{}", scKey);
} else if (key.isReadable()) { // 如果是 read
try {
SocketChannel channel = (SocketChannel) key.channel(); // 拿到觸發事件的channel
// 獲取 selectionKey 上關聯的附件
ByteBuffer buffer = (ByteBuffer) key.attachment();
int read = channel.read(buffer); // 如果是正常斷開，read 的方法的返回值是 -1
if(read == -1) {
key.cancel();
} else {
split(buffer);
// 需要擴容
if (buffer.position() == buffer.limit()) {
ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity() * 2);
buffer.flip();
newBuffer.put(buffer); // 0123456789abcdef3333\n
key.attach(newBuffer);
}
}
} catch (IOException e) {
e.printStackTrace();
key.cancel(); // 因為客戶端斷開了,因此需要將 key 取消（從 selector 的 keys 集合中真正刪除 key）
}
}
}
}
}
客戶端
SocketChannel sc = SocketChannel.open();
sc.connect(new InetSocketAddress("localhost", 8080));
SocketAddress address = sc.getLocalAddress();
// sc.write(Charset.defaultCharset().encode("hello\nworld\n"));
sc.write(Charset.defaultCharset().encode("0123\n456789abcdef"));
sc.write(Charset.defaultCharset().encode("0123456789abcdef3333\n"));
System.in.read();
ByteBuffer 大小分配
- 每個 channel 都需要記錄可能被切分的訊息，因為 ByteBuffer 不能被多個 channel 共同使用，因此需要為每個 channel 維護一個獨立的 ByteBuffer
- ByteBuffer 不能太大，比如一個 ByteBuffer 1Mb 的話，要支援百萬連線就要 1Tb 記憶體，因此需要設計大小可變的 ByteBuffer
- 一種思路是首先分配一個較小的 buffer，例如 4k，如果發現資料不夠，再分配 8k 的 buffer，將 4k buffer 內容複製至 8k buffer，優點是訊息連續容易處理，缺點是資料複製耗費效能，參考實現 http://tutorials.jenkov.com/java-performance/resizable-array.html
- 另一種思路是用多個陣列組成 buffer，一個陣列不夠，把多出來的內容寫入新的陣列，與前面的區別是訊息儲存不連續解析複雜，優點是避免了複製引起的效能損耗
4.5 處理 write 事件
一次無法寫完例子
- 非阻塞模式下，無法保證把 buffer 中所有資料都寫入 channel，因此需要追蹤 write 方法的返回值（代表實際寫入位元組數）
- 用 selector 監聽所有 channel 的可寫事件，每個 channel 都需要一個 key 來跟蹤 buffer，但這樣又會導致佔用記憶體過多，就有兩階段策略
- 當訊息處理器第一次寫入訊息時，才將 channel 註冊到 selector 上
- selector 檢查 channel 上的可寫事件，如果所有的資料寫完了，就取消 channel 的註冊
- 如果不取消，會每次可寫均會觸發 write 事件
public class WriteServer {
public static void main(String[] args) throws IOException {
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.bind(new InetSocketAddress(8080));
Selector selector = Selector.open();
ssc.register(selector, SelectionKey.OP_ACCEPT);
while(true) {
selector.select();
Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
if (key.isAcceptable()) {
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
SelectionKey sckey = sc.register(selector, SelectionKey.OP_READ);
// 1. 向客戶端傳送內容
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 3000000; i++) {
sb.append("a");
}
ByteBuffer buffer = Charset.defaultCharset().encode(sb.toString());
int write = sc.write(buffer);
// 3. write 表示實際寫了多少位元組
System.out.println("實際寫入位元組:" + write);
// 4. 如果有剩餘未讀位元組，才需要關注寫事件
if (buffer.hasRemaining()) {
// read 1 write 4
// 在原有關注事件的基礎上，多關注 寫事件
sckey.interestOps(sckey.interestOps() + SelectionKey.OP_WRITE);
// 把 buffer 作為附件加入 sckey
sckey.attach(buffer);
}
} else if (key.isWritable()) {
ByteBuffer buffer = (ByteBuffer) key.attachment();
SocketChannel sc = (SocketChannel) key.channel();
int write = sc.write(buffer);
System.out.println("實際寫入位元組:" + write);
if (!buffer.hasRemaining()) { // 寫完了
key.interestOps(key.interestOps() - SelectionKey.OP_WRITE);
key.attach(null);
}
}
}
}
}
}
客戶端
public class WriteClient {
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
SocketChannel sc = SocketChannel.open();
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_CONNECT | SelectionKey.OP_READ);
sc.connect(new InetSocketAddress("localhost", 8080));
int count = 0;
while (true) {
selector.select();
Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
if (key.isConnectable()) {
System.out.println(sc.finishConnect());
} else if (key.isReadable()) {
ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
count += sc.read(buffer);
buffer.clear();
System.out.println(count);
}
}
}
}
}
💡 write 為何要取消
只要向 channel 傳送資料時，socket 緩衝可寫，這個事件會頻繁觸發，因此應當只在 socket 緩衝區寫不下時再關注可寫事件，資料寫完之後再取消關注
4.6 更進一步
💡 利用多執行緒最佳化
現在都是多核 cpu，設計時要充分考慮別讓 cpu 的力量被白白浪費
前面的程式碼只有一個選擇器，沒有充分利用多核 cpu，如何改進呢？
分兩組選擇器
- 單執行緒配一個選擇器，專門處理 accept 事件
- 建立 cpu 核心數的執行緒，每個執行緒配一個選擇器，輪流處理 read 事件
public class ChannelDemo7 {
public static void main(String[] args) throws IOException {
new BossEventLoop().register();
}
@Slf4j
static class BossEventLoop implements Runnable {
private Selector boss;
private WorkerEventLoop[] workers;
private volatile boolean start = false;
AtomicInteger index = new AtomicInteger();
public void register() throws IOException {
if (!start) {
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.bind(new InetSocketAddress(8080));
ssc.configureBlocking(false);
boss = Selector.open();
SelectionKey ssckey = ssc.register(boss, 0, null);
ssckey.interestOps(SelectionKey.OP_ACCEPT);
workers = initEventLoops();
new Thread(this, "boss").start();
log.debug("boss start...");
start = true;
}
}
public WorkerEventLoop[] initEventLoops() {
// EventLoop[] eventLoops = new EventLoop[Runtime.getRuntime().availableProcessors()];
WorkerEventLoop[] workerEventLoops = new WorkerEventLoop[2];
for (int i = 0; i < workerEventLoops.length; i++) {
workerEventLoops[i] = new WorkerEventLoop(i);
}
return workerEventLoops;
}
@Override
public void run() {
while (true) {
try {
boss.select();
Iterator<SelectionKey> iter = boss.selectedKeys().iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
if (key.isAcceptable()) {
ServerSocketChannel c = (ServerSocketChannel) key.channel();
SocketChannel sc = c.accept();
sc.configureBlocking(false);
log.debug("{} connected", sc.getRemoteAddress());
workers[index.getAndIncrement() % workers.length].register(sc);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Slf4j
static class WorkerEventLoop implements Runnable {
private Selector worker;
private volatile boolean start = false;
private int index;
private final ConcurrentLinkedQueue<Runnable> tasks = new ConcurrentLinkedQueue<>();
public WorkerEventLoop(int index) {
this.index = index;
}
public void register(SocketChannel sc) throws IOException {
if (!start) {
worker = Selector.open();
new Thread(this, "worker-" + index).start();
start = true;
}
tasks.add(() -> {
try {
SelectionKey sckey = sc.register(worker, 0, null);
sckey.interestOps(SelectionKey.OP_READ);
worker.selectNow();
} catch (IOException e) {
e.printStackTrace();
}
});
worker.wakeup();
}
@Override
public void run() {
while (true) {
try {
worker.select();
Runnable task = tasks.poll();
if (task != null) {
task.run();
}
Set<SelectionKey> keys = worker.selectedKeys();
Iterator<SelectionKey> iter = keys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
if (key.isReadable()) {
SocketChannel sc = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(128);
try {
int read = sc.read(buffer);
if (read == -1) {
key.cancel();
sc.close();
} else {
buffer.flip();
log.debug("{} message:", sc.getRemoteAddress());
debugAll(buffer);
}
} catch (IOException e) {
e.printStackTrace();
key.cancel();
sc.close();
}
}
iter.remove();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
💡 如何拿到 cpu 個數
- Runtime.getRuntime().availableProcessors() 如果工作在 docker 容器下，因為容器不是物理隔離的，會拿到物理 cpu 個數，而不是容器申請時的個數
- 這個問題直到 jdk 10 才修復，使用 jvm 引數 UseContainerSupport 配置， 預設開啟
4.7 UDP
- UDP 是無連線的，client 傳送資料不會管 server 是否開啟
- server 這邊的 receive 方法會將接收到的資料存入 byte buffer，但如果資料包文超過 buffer 大小，多出來的資料會被默默拋棄
首先啟動伺服器端
public class UdpServer {
public static void main(String[] args) {
try (DatagramChannel channel = DatagramChannel.open()) {
channel.socket().bind(new InetSocketAddress(9999));
System.out.println("waiting...");
ByteBuffer buffer = ByteBuffer.allocate(32);
channel.receive(buffer);
buffer.flip();
debug(buffer);
} catch (IOException e) {
e.printStackTrace();
}
}
}
輸出
waiting...
執行客戶端
public class UdpClient {
public static void main(String[] args) {
try (DatagramChannel channel = DatagramChannel.open()) {
ByteBuffer buffer = StandardCharsets.UTF_8.encode("hello");
InetSocketAddress address = new InetSocketAddress("localhost", 9999);
channel.send(buffer, address);
} catch (Exception e) {
e.printStackTrace();
}
}
}
接下來伺服器端輸出
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f |hello |
+--------+-------------------------------------------------+----------------+
5. NIO vs BIO
5.1 stream vs channel
- stream 不會自動緩衝資料，channel 會利用系統提供的傳送緩衝區、接收緩衝區（更為底層）
- stream 僅支援阻塞 API，channel 同時支援阻塞、非阻塞 API，網路 channel 可配合 selector 實現多路複用
- 二者均為全雙工，即讀寫可以同時進行
5.2 IO 模型
同步阻塞、同步非阻塞、同步多路複用、非同步阻塞（沒有此情況）、非同步非阻塞
- 同步：執行緒自己去獲取結果（一個執行緒）
- 非同步：執行緒自己不去獲取結果，而是由其它執行緒送結果（至少兩個執行緒）
當呼叫一次 channel.read 或 stream.read 後，會切換至作業系統核心態來完成真正資料讀取，而讀取又分為兩個階段，分別為：
- 等待資料階段
- 複製資料階段
-
阻塞 IO
-
非阻塞 IO
-
多路複用
-
訊號驅動
-
非同步 IO
-
阻塞 IO vs 多路複用
🔖 參考
UNIX 網路程式設計 - 卷 I
5.3 零複製
傳統 IO 問題
傳統的 IO 將一個檔案透過 socket 寫出
File f = new File("helloword/data.txt");
RandomAccessFile file = new RandomAccessFile(file, "r");
byte[] buf = new byte[(int)f.length()];
file.read(buf);
Socket socket = ...;
socket.getOutputStream().write(buf);
內部工作流程是這樣的：
-
java 本身並不具備 IO 讀寫能力，因此 read 方法呼叫後，要從 java 程式的使用者態切換至核心態，去呼叫作業系統（Kernel）的讀能力，將資料讀入核心緩衝區。這期間使用者執行緒阻塞，作業系統使用 DMA（Direct Memory Access）來實現檔案讀，其間也不會使用 cpu
DMA 也可以理解為硬體單元，用來解放 cpu 完成檔案 IO
-
從核心態切換回使用者態，將資料從核心緩衝區讀入使用者緩衝區（即 byte[] buf），這期間 cpu 會參與複製，無法利用 DMA
-
呼叫 write 方法，這時將資料從使用者緩衝區（byte[] buf）寫入 socket 緩衝區，cpu 會參與複製
-
接下來要向網路卡寫資料，這項能力 java 又不具備，因此又得從使用者態切換至核心態，呼叫作業系統的寫能力，使用 DMA 將 socket 緩衝區的資料寫入網路卡，不會使用 cpu
可以看到中間環節較多，java 的 IO 實際不是物理裝置級別的讀寫，而是快取的複製，底層的真正讀寫是作業系統來完成的
- 使用者態與核心態的切換髮生了 3 次，這個操作比較重量級
- 資料複製了共 4 次
NIO 最佳化
透過 DirectByteBuf
- ByteBuffer.allocate(10) HeapByteBuffer 使用的還是 java 記憶體
- ByteBuffer.allocateDirect(10) DirectByteBuffer 使用的是作業系統記憶體
大部分步驟與最佳化前相同，不再贅述。唯有一點：java 可以使用 DirectByteBuf 將堆外記憶體對映到 jvm 記憶體中來直接訪問使用
- 這塊記憶體不受 jvm 垃圾回收的影響，因此記憶體地址固定，有助於 IO 讀寫
- java 中的 DirectByteBuf 物件僅維護了此記憶體的虛引用，記憶體回收分成兩步
- DirectByteBuf 物件被垃圾回收，將虛引用加入引用佇列
- 透過專門執行緒訪問引用佇列，根據虛引用釋放堆外記憶體
- 減少了一次資料複製，使用者態與核心態的切換次數沒有減少
進一步最佳化（底層採用了 linux 2.1 後提供的 sendFile 方法），java 中對應著兩個 channel 呼叫 transferTo/transferFrom 方法複製資料
- java 呼叫 transferTo 方法後，要從 java 程式的使用者態切換至核心態，使用 DMA將資料讀入核心緩衝區，不會使用 cpu
- 資料從核心緩衝區傳輸到 socket 緩衝區，cpu 會參與複製
- 最後使用 DMA 將 socket 緩衝區的資料寫入網路卡，不會使用 cpu
可以看到
- 只發生了一次使用者態與核心態的切換
- 資料複製了 3 次
進一步最佳化（linux 2.4）
- java 呼叫 transferTo 方法後，要從 java 程式的使用者態切換至核心態，使用 DMA將資料讀入核心緩衝區，不會使用 cpu
- 只會將一些 offset 和 length 資訊拷入 socket 緩衝區，幾乎無消耗
- 使用 DMA 將 核心緩衝區的資料寫入網路卡，不會使用 cpu
整個過程僅只發生了一次使用者態與核心態的切換，資料複製了 2 次。所謂的【零複製】，並不是真正無複製，而是在不會複製重複資料到 jvm 記憶體中，零複製的優點有
- 更少的使用者態與核心態的切換
- 不利用 cpu 計算，減少 cpu 快取偽共享
- 零複製適合小檔案傳輸
5.3 AIO
AIO 用來解決資料複製階段的阻塞問題
- 同步意味著，在進行讀寫操作時，執行緒需要等待結果，還是相當於閒置
- 非同步意味著，在進行讀寫操作時，執行緒不必等待結果，而是將來由作業系統來透過回撥方式由另外的執行緒來獲得結果
非同步模型需要底層作業系統（Kernel）提供支援
- Windows 系統透過 IOCP 實現了真正的非同步 IO
- Linux 系統非同步 IO 在 2.6 版本引入，但其底層實現還是用多路複用模擬了非同步 IO，效能沒有優勢
檔案 AIO
先來看看 AsynchronousFileChannel
@Slf4j
public class AioDemo1 {
public static void main(String[] args) throws IOException {
try{
AsynchronousFileChannel s =
AsynchronousFileChannel.open(
Paths.get("1.txt"), StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(2);
log.debug("begin...");
s.read(buffer, 0, null, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
log.debug("read completed...{}", result);
buffer.flip();
debug(buffer);
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
log.debug("read failed...");
}
});
} catch (IOException e) {
e.printStackTrace();
}
log.debug("do other things...");
System.in.read();
}
}
輸出
13:44:56 [DEBUG] [main] c.i.aio.AioDemo1 - begin...
13:44:56 [DEBUG] [main] c.i.aio.AioDemo1 - do other things...
13:44:56 [DEBUG] [Thread-5] c.i.aio.AioDemo1 - read completed...2
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 0d |a. |
+--------+-------------------------------------------------+----------------+
可以看到
- 響應檔案讀取成功的是另一個執行緒 Thread-5
- 主執行緒並沒有 IO 操作阻塞
💡 守護執行緒
預設檔案 AIO 使用的執行緒都是守護執行緒，所以最後要執行 System.in.read() 以避免守護執行緒意外結束
網路 AIO
public class AioServer {
public static void main(String[] args) throws IOException {
AsynchronousServerSocketChannel ssc = AsynchronousServerSocketChannel.open();
ssc.bind(new InetSocketAddress(8080));
ssc.accept(null, new AcceptHandler(ssc));
System.in.read();
}
private static void closeChannel(AsynchronousSocketChannel sc) {
try {
System.out.printf("[%s] %s close\n", Thread.currentThread().getName(), sc.getRemoteAddress());
sc.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
private final AsynchronousSocketChannel sc;
public ReadHandler(AsynchronousSocketChannel sc) {
this.sc = sc;
}
@Override
public void completed(Integer result, ByteBuffer attachment) {
try {
if (result == -1) {
closeChannel(sc);
return;
}
System.out.printf("[%s] %s read\n", Thread.currentThread().getName(), sc.getRemoteAddress());
attachment.flip();
System.out.println(Charset.defaultCharset().decode(attachment));
attachment.clear();
// 處理完第一個 read 時，需要再次呼叫 read 方法來處理下一個 read 事件
sc.read(attachment, attachment, this);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
closeChannel(sc);
exc.printStackTrace();
}
}
private static class WriteHandler implements CompletionHandler<Integer, ByteBuffer> {
private final AsynchronousSocketChannel sc;
private WriteHandler(AsynchronousSocketChannel sc) {
this.sc = sc;
}
@Override
public void completed(Integer result, ByteBuffer attachment) {
// 如果作為附件的 buffer 還有內容，需要再次 write 寫出剩餘內容
if (attachment.hasRemaining()) {
sc.write(attachment);
}
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
exc.printStackTrace();
closeChannel(sc);
}
}
private static class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, Object> {
private final AsynchronousServerSocketChannel ssc;
public AcceptHandler(AsynchronousServerSocketChannel ssc) {
this.ssc = ssc;
}
@Override
public void completed(AsynchronousSocketChannel sc, Object attachment) {
try {
System.out.printf("[%s] %s connected\n", Thread.currentThread().getName(), sc.getRemoteAddress());
} catch (IOException e) {
e.printStackTrace();
}
ByteBuffer buffer = ByteBuffer.allocate(16);
// 讀事件由 ReadHandler 處理
sc.read(buffer, buffer, new ReadHandler(sc));
// 寫事件由 WriteHandler 處理
sc.write(Charset.defaultCharset().encode("server hello!"), ByteBuffer.allocate(16), new WriteHandler(sc));
// 處理完第一個 accpet 時，需要再次呼叫 accept 方法來處理下一個 accept 事件
ssc.accept(null, this);
}
@Override
public void failed(Throwable exc, Object attachment) {
exc.printStackTrace();
}
}
}