non-blocking io 非阻塞 IO
1.1 Channel & Buffe
channel 有一点类似于 stream,它就是读写数据的双向通道,可以从 channel 将数据读入 buffer,也可以将 buffer 的数据写入 channel,而之前的 stream 要么是输入,要么是输出,channel 比 stream 更为底层
常见的 Channel 有
buffer 则用来缓冲读写数据,常见的 buffer 有
selector 单从字面意思不好理解,需要结合服务器的设计演化来理解它的用途
selector 的作用就是配合一个线程来管理多个 channel,获取这些 channel 上发生的事件,这些 channel 工作在非阻塞模式下,不会让线程吊死在一个 channel 上。适合连接数特别多,但流量低的场景(low traffic)
调用 selector 的 select() 会阻塞直到 channel 发生了读写就绪事件,这些事件发生,select 方法就会返回这些事件交给 thread 来处理
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.3.0-alpha4</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.66.Final</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1.1-jre</version>
</dependency>
有一普通文本文件 data.txt,内容为
1234567890abcd
使用 FileChannel 来读取文件内容
@Slf4j
public class ChannelDemo1 {
public static void main(String[] args) {
try (RandomAccessFile file = new RandomAccessFile("helloword/data.txt", "rw")) {
FileChannel channel = file.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(10);
do {
// 向 buffer 写入
int len = channel.read(buffer);
log.debug("读到字节数:{}", len);
if (len == -1) {
break;
}
// 切换 buffer 读模式
buffer.flip();
while(buffer.hasRemaining()) {
log.debug("{}", (char)buffer.get());
}
// 切换 buffer 写模式
buffer.clear();
} while (true);
} catch (IOException e) {
e.printStackTrace();
}
}
}
输出
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数:10
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 1
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 2
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 3
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 4
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 5
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 6
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 7
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 8
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 9
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 0
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数:4
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - a
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - b
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - c
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - d
10:39:03 [DEBUG] [main] c.i.n.ChannelDemo1 - 读到字节数:-1
ByteBuffer 有以下重要属性
一开始
写模式下,position 是写入位置,limit 等于容量,下图表示写入了 4 个字节后的状态
flip 动作发生后,position 切换为读取位置,limit 切换为读取限制
读取 4 个字节后,状态
clear 动作发生后,状态
compact 方法,是把未读完的部分向前压缩,然后切换至写模式
可以在控制台上面输出当前Buffer的详细情况,内部用到了guava和netty-all jar包中的相关类
public class ByteBufferUtil {
private static final char[] BYTE2CHAR = new char[256];
private static final char[] HEXDUMP_TABLE = new char[256 * 4];
private static final String[] HEXPADDING = new String[16];
private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
private static final String[] BYTE2HEX = new String[256];
private static final String[] BYTEPADDING = new String[16];
static {
final char[] DIGITS = "0123456789abcdef".toCharArray();
for (int i = 0; i < 256; i++) {
HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
}
int i;
// Generate the lookup table for hex dump paddings
for (i = 0; i < HEXPADDING.length; i++) {
int padding = HEXPADDING.length - i;
StringBuilder buf = new StringBuilder(padding * 3);
for (int j = 0; j < padding; j++) {
buf.append(" ");
}
HEXPADDING[i] = buf.toString();
}
// Generate the lookup table for the start-offset header in each row (up to 64KiB).
for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
StringBuilder buf = new StringBuilder(12);
buf.append(NEWLINE);
buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
buf.setCharAt(buf.length() - 9, '|');
buf.append('|');
HEXDUMP_ROWPREFIXES[i] = buf.toString();
}
// Generate the lookup table for byte-to-hex-dump conversion
for (i = 0; i < BYTE2HEX.length; i++) {
BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
}
// Generate the lookup table for byte dump paddings
for (i = 0; i < BYTEPADDING.length; i++) {
int padding = BYTEPADDING.length - i;
StringBuilder buf = new StringBuilder(padding);
for (int j = 0; j < padding; j++) {
buf.append(' ');
}
BYTEPADDING[i] = buf.toString();
}
// Generate the lookup table for byte-to-char conversion
for (i = 0; i < BYTE2CHAR.length; i++) {
if (i <= 0x1f || i >= 0x7f) {
BYTE2CHAR[i] = '.';
} else {
BYTE2CHAR[i] = (char) i;
}
}
}
/**
* 打印所有内容
* @param buffer
*/
public static void debugAll(ByteBuffer buffer) {
int oldlimit = buffer.limit();
buffer.limit(buffer.capacity());
StringBuilder origin = new StringBuilder(256);
appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
System.out.println("+--------+-------------------- all ------------------------+----------------+");
System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
System.out.println(origin);
buffer.limit(oldlimit);
}
/**
* 打印可读取内容
* @param buffer
*/
public static void debugRead(ByteBuffer buffer) {
StringBuilder builder = new StringBuilder(256);
appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
System.out.println("+--------+-------------------- read -----------------------+----------------+");
System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
System.out.println(builder);
}
private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
if (isOutOfBounds(offset, length, buf.capacity())) {
throw new IndexOutOfBoundsException(
"expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
+ ") <= " + "buf.capacity(" + buf.capacity() + ')');
}
if (length == 0) {
return;
}
dump.append(
" +-------------------------------------------------+" +
NEWLINE + " | 0 1 2 3 4 5 6 7 8 9 a b c d e f |" +
NEWLINE + "+--------+-------------------------------------------------+----------------+");
final int startIndex = offset;
final int fullRows = length >>> 4;
final int remainder = length & 0xF;
// Dump the rows which have 16 bytes.
for (int row = 0; row < fullRows; row++) {
int rowStartIndex = (row << 4) + startIndex;
// Per-row prefix.
appendHexDumpRowPrefix(dump, row, rowStartIndex);
// Hex dump
int rowEndIndex = rowStartIndex + 16;
for (int j = rowStartIndex; j < rowEndIndex; j++) {
dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
}
dump.append(" |");
// ASCII dump
for (int j = rowStartIndex; j < rowEndIndex; j++) {
dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
}
dump.append('|');
}
// Dump the last row which has less than 16 bytes.
if (remainder != 0) {
int rowStartIndex = (fullRows << 4) + startIndex;
appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);
// Hex dump
int rowEndIndex = rowStartIndex + remainder;
for (int j = rowStartIndex; j < rowEndIndex; j++) {
dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
}
dump.append(HEXPADDING[remainder]);
dump.append(" |");
// Ascii dump
for (int j = rowStartIndex; j < rowEndIndex; j++) {
dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
}
dump.append(BYTEPADDING[remainder]);
dump.append('|');
}
dump.append(NEWLINE +
"+--------+-------------------------------------------------+----------------+");
}
private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
if (row < HEXDUMP_ROWPREFIXES.length) {
dump.append(HEXDUMP_ROWPREFIXES[row]);
} else {
dump.append(NEWLINE);
dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
dump.setCharAt(dump.length() - 9, '|');
dump.append('|');
}
}
public static short getUnsignedByte(ByteBuffer buffer, int index) {
return (short) (buffer.get(index) & 0xFF);
}
}
可以使用 allocate 方法为 ByteBuffer 分配空间,其它 buffer 类也有该方法
Bytebuffer buf = ByteBuffer.allocate(16);
有两种办法
int readBytes = channel.read(buf);
和
buf.put((byte)127);
同样有两种办法
int writeBytes = channel.write(buf);
和
byte b = buf.get();
get 方法会让 position 读指针向后走,如果想重复读取数据
mark 是在读取时,做一个标记,即使 position 改变,只要调用 reset 就能回到 mark 的位置
注意 rewind 和 flip 都会清除 mark 位置
ByteBuffer buffer1 = StandardCharsets.UTF_8.encode("你好");
ByteBuffer buffer2 = Charset.forName("utf-8").encode("你好");
debugAll(buffer1);
debugAll(buffer2);
CharBuffer buffer3 = StandardCharsets.UTF_8.decode(buffer1);
System.out.println(buffer3.getClass());
System.out.println(buffer3.toString());
输出
下面输出的是十六进制
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [6]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| e4 bd a0 e5 a5 bd 00 00 00 00 00 |........... |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [6]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| e4 bd a0 e5 a5 bd 00 00 00 00 00 |........... |
+--------+-------------------------------------------------+----------------+
class java.nio.HeapCharBuffer
你好
Buffer 是非线程安全的
分散读取,有一个文本文件 1.txt
dhyxpy1314
使用如下方式读取,可以将数据填充至多个 buffer
try (RandomAccessFile file = new RandomAccessFile("1.txt", "rw")) {
FileChannel channel = file.getChannel();
ByteBuffer a = ByteBuffer.allocate(3);
ByteBuffer b = ByteBuffer.allocate(3);
ByteBuffer c = ByteBuffer.allocate(4);
channel.read(new ByteBuffer[]{a, b, c});
a.flip();
b.flip();
c.flip();
debugAll(a);
debugAll(b);
debugAll(c);
} catch (IOException e) {
e.printStackTrace();
}
结果
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [3]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 64 68 79 |dhy |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [3]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 78 70 79 |xpy |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [4]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 31 33 31 34 |1314 |
+--------+-------------------------------------------------+----------------+
使用如下方式写入,可以将多个 buffer 的数据填充至 channel
try (RandomAccessFile file = new RandomAccessFile("1.txt", "rw")) {
FileChannel channel = file.getChannel();
ByteBuffer d = ByteBuffer.allocate(3);
ByteBuffer e = ByteBuffer.allocate(3);
//设置当前文件通道初始读写的位置
channel.position(10);
d.put(new byte[]{'f', 'o', 'r'});
e.put(new byte[]{'g', 'e', 't'});
//切换读取模式
d.flip();
e.flip();
debugAll(d);
debugAll(e);
channel.write(new ByteBuffer[]{d, e});
} catch (IOException e) {
e.printStackTrace();
}
输出
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [3]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 66 6f 72 |for |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [3]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 67 65 74 |get |
+--------+-------------------------------------------------+----------------+
文件内容
网络上有多条数据发送给服务端,数据之间使用 \n 进行分隔 但由于某种原因这些数据在接收时,被进行了重新组合,例如原始数据有3条为
变成了下面的两个 byteBuffer (黏包,半包)
现在要求你编写程序,将错乱的数据恢复成原始的按 \n 分隔的数据
/**
* @author 大忽悠
* @create 2022/1/16 14:23
*/
public class Main
{
public static void main(String[] args) {
ByteBuffer source = ByteBuffer.allocate(32);
// 11 24
source.put("Hello,world\nI'm DHY\nHo".getBytes());
split(source);
source.put("w are you?\nhaha!\n".getBytes());
split(source);
}
private static void split(ByteBuffer source) {
//切换读写模式
source.flip();
//读的最大距离
int oldLimit = source.limit();
for (int i = 0; i < oldLimit; i++) {
//\n表示一句话读取完毕
if (source.get(i) == '\n')
{
//打印换行符的下标
System.out.println(i);
//分配的缓冲区大小为当前一句话的大小
ByteBuffer target = ByteBuffer.allocate(i + 1 - source.position());
// 0 ~ limit----设置limit的新位置
source.limit(i + 1);
//把position-->limit之间的数据全部放入target缓冲区中
target.put(source); // 从source 读,向 target 写
debugAll(target);
//恢复为原来最远读取距离
source.limit(oldLimit);
}
}
//将还未读取的数据移动到缓冲区头部
source.compact();
}
}
输出
11
+--------+-------------------- all ------------------------+----------------+
position: [12], limit: [12]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 2c 77 6f 72 6c 64 0a |Hello,world. |
+--------+-------------------------------------------------+----------------+
19
+--------+-------------------- all ------------------------+----------------+
position: [8], limit: [8]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 49 27 6d 20 44 48 59 0a |I'm DHY. |
+--------+-------------------------------------------------+----------------+
12
+--------+-------------------- all ------------------------+----------------+
position: [13], limit: [13]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 6f 77 20 61 72 65 20 79 6f 75 3f 0a |How are you?. |
+--------+-------------------------------------------------+----------------+
18
+--------+-------------------- all ------------------------+----------------+
position: [6], limit: [6]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 61 68 61 21 0a |haha!. |
+--------+-------------------------------------------------+----------------+
FileChannel 只能工作在阻塞模式下
不能直接打开 FileChannel,必须通过 FileInputStream、FileOutputStream 或者 RandomAccessFile 来获取 FileChannel,它们都有 getChannel 方法
会从 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 方法
获取当前位置
long pos = channel.position();
设置当前位置
long newPos = ...;
channel.position(newPos);
设置当前位置时,如果设置为文件的末尾
使用 size 方法获取文件的大小
操作系统出于性能的考虑,会将数据先缓存,不是立刻写入磁盘。可以调用 force(true) 方法将文件内容和元数据(文件的权限等信息)立刻写入磁盘
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数据,超过 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);
//transferTo返回值表示一次传输了多少个字节
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
jdk7 引入了 Path 和 Paths 类
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
检查文件是否存在
Path path = Paths.get("helloword/data.txt");
System.out.println(Files.exists(path));
创建一级目录
Path path = Paths.get("helloword/d1");
Files.createDirectory(path);
创建多级目录用
Path path = Paths.get("helloword/d1/d2");
Files.createDirectories(path);
拷贝文件
这里copy底层也是操作系统实现的,效率较高,和transfromto类似
Path source = Paths.get("helloword/data.txt");
Path target = Paths.get("helloword/target.txt");
Files.copy(source, target);
如果希望用 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);
删除目录
Path target = Paths.get("helloword/d1");
Files.delete(target);
遍历目录文件
/**
* @author 大忽悠
* @create 2022/1/16 14:23
*/
public class Main
{
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\zdh\\Desktop\\hhh");
//累加器记录
//记录目录数量
LongAdder dirCount=new LongAdder();
//记录文件数量
LongAdder fileCount=new LongAdder();
//这里使用了访问者模式
Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs)
throws IOException {
System.out.println(dir);
dirCount.increment();
return super.preVisitDirectory(dir, attrs);
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
System.out.println(file);
fileCount.increment();
return super.visitFile(file, attrs);
}
});
System.out.println("目录数量: "+dirCount); // 133
System.out.println("文件数量: "+fileCount); // 1479
}
}
Path.endswith() 的是 Path 不是文件名后缀 Path.endswith() 的是 Path 不是文件名后缀
统计.png文件的数量:
/
* @author 大忽悠
* @create 2022/1/16 14:23
*/
public class Main
{
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\zdh\\Desktop\\hhh");
//累加器记录
//记录文件数量
LongAdder fileCount=new LongAdder();
//这里使用了访问者模式
Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
if(file.toFile().getName().endsWith(".png"))
{
System.out.println(file);
fileCount.increment();
}
return super.visitFile(file, attrs);
}
});
System.out.println("文件数量: "+fileCount); // 1479
}
}
删除多级目录
public class Main
{
public static void main(String[] args) throws IOException {
Path path = Paths.get("C:\\Users\\zdh\\Desktop\\1");
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);
ServerSocketChannel.accept 会在没有连接建立时让线程暂停
SocketChannel.read 会在没有数据可读时让线程暂停
阻塞的表现其实就是线程暂停了,暂停期间不会占用 cpu,但线程相当于闲置
服务器端
// 使用 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 通过网络把数据发送出去
数据复制过程中,线程实际还是阻塞的(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 可读写事件的监控,这称之为多路复用
好处
Selector selector = Selector.open();
也称之为注册事件,绑定的事件 selector 才会关心
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, 绑定事件);
FileChannel 没有非阻塞模式,因此不能配合 selector 一起使用
可以通过下面三种方法来监听是否有事件发生,方法的返回值代表有多少 channel 发生了事件
方法1,阻塞直到绑定事件发生
int count = selector.select();
方法2,阻塞直到绑定事件发生,或是超时(时间单位为 ms)
int count = selector.select(long timeout);
方法3,不会阻塞,也就是不管有没有事件,立刻返回,自己根据返回值检查是否有事件
int count = selector.selectNow();
客户端发送数据过来,客户端正常、异常关闭时,都会触发 read 事件,另外如果发送的数据大于 buffer 缓冲区,会触发多次读取事件
selector 所在线程 interrupt
客户端代码为
public class Client {
public static void main(String[] args) {
try (Socket socket = new Socket("localhost", 19999)) {
System.out.println(socket);
socket.getOutputStream().write("world".getBytes());
//以控制台的输入数据作为输入流的来源,每次读取一个字节的数据
//可以通过返回值强转char,得到读取的字节内容
//这里为了阻塞当前客户端,不让其断开连接
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(19999));
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();
}
}
}
事件发生后,要么处理(处理完对应事件后,从准备好的SelectionKey 集合中移除对应的处理完的SelectionKey ),要么取消(cancel),不能什么都不做,否则下次该事件仍会触发,这是因为 nio 底层使用的是水平触发
select方法在有事件未处理时,不会阻塞
iter.remove();作用图解
每个Selector对象都需要维护以下三个集合:
1.已注册的键的集合,keys()方法返回这个已注册的键的集合,这个集合不能修改
2.已选择的键的集合,selectedKeys()方法返回,该集合中的每个成员都是相关的通道被选择器判断已经准备好的,并且包含了键的interest集合中的操作,键可以从集合中移除,不能添加.
3.已取消的键的集合,这个集合包含了调用过cancel()方法的键
上面没有画出已取消键的集合
@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 = null;
try {
sc= (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(128);
int read = sc.read(buffer);
//客户端正常关闭连接
if(read == -1) {
key.cancel();
sc.close();
}
else {
buffer.flip();
debugAll(buffer);
}
} catch (IOException e) {
//客户端非正常断开连接
sc.close();
key.cancel();
}
}
// 处理完毕,必须将事件移除
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 |
+--------+-------------------------------------------------+----------------+
因为 select 在事件发生后,就会将相关的 key 放入 selectedKeys 集合,但不会在处理完后从 selectedKeys 集合中移除,需要我们自己编码删除。例如
cancel 会取消注册在 selector 上的 channel,并从 keys 集合中删除 key 后续不会再监听事件
注意:cancel是将当前selectionkey添加进cancelKeys的集合,然后每一次调用select方法的时候,都会检查已取消的键的集合,如果该集合非空,就把该集合中的键从另外两个集合中移除,注销相关的通道,这个步骤结束后,已取消的集合应该是空的
为了处理,我们需要对异常关闭try…catch捕获后,在catch块中调用key.cancel();,从 keys 集合中删除 key 后续不会再监听事件
对于正常关闭的客户端,我们只需要判断int read = sc.read(buffer);的返回结果是否是-1即可,如果是调用key.cancel();,从 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�
�好
为什么?
这里先采用按分隔符分割的方法来解决消息边界的问题:
服务器端
这里用到了一开始解决黏包和半包问题的split方法
/**
* @author 大忽悠
* @create 2022/1/16 22:05
*/
@Slf4j
public class Main
{
private static void split(ByteBuffer source)
{
//切换读写模式
source.flip();
for (int i = 0; i < source.limit(); i++) {
// 找到一条完整消息---get(i)不会移动position指针的位置
if (source.get(i) == '\n')
{
//计算当前消息一共多少个字节
int length = i + 1 - source.position();
// 把这条完整消息存入新的ByteBuffer---分配缓冲区大小
ByteBuffer target = ByteBuffer.allocate(length);
// 从 source 读,向 target 写--一共读取lengt个字节数据
for (int j = 0; j < length; j++) {
//不断移动position指针来读取,然后放入缓冲区中
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 作为附件关联到 selectionKey 上
SelectionKey scKey = sc.register(selector, 0, buffer);
//更新附加为扩容后的缓冲区大小
key.attach(newBuffer);
客户端:
/**
* @author 大忽悠
*/
public class WriteClient {
private static Selector selector;
private static SocketChannel sc;
/**
* 建立与服务器的连接
*/
public static void buildConnection()
{
try {
selector = Selector.open();
sc = SocketChannel.open();
sc.configureBlocking(false);
//监听与服务器的连接建立事件和服务器发送过来的可读数据事件
sc.register(selector, SelectionKey.OP_CONNECT | SelectionKey.OP_READ);
//连接服务器
sc.connect(new InetSocketAddress("localhost", 8080));
}
catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
//建立连接
buildConnection();
//计算总共读取的字节数
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()) {
//finishConnect是否完成了连接
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);
}
}
}
}
}
服务端:
/**
* @author 大忽悠
*/
public class WriteServer {
private static ServerSocketChannel ssc;
private static Selector selector;
/**
* 建立连接
*/
public static void buildConnection()
{
try {
ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.bind(new InetSocketAddress(8080));
selector = Selector.open();
ssc.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException
{
buildConnection();
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
ByteBuffer buffer = Charset.defaultCharset().encode(sb.toString());
//缓冲区还有数据没读取完
while(buffer.hasRemaining())
{
int write = sc.write(buffer);
System.out.println("写入的字节数: "+write);
}
}
}
}
}
}
服务器端输出:
写入的字节数: 2883562
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 0
写入的字节数: 116438
客户端输出:
true
131071
262142
393213
524284
655355
786426
917497
1048568
1179639
1310710
1441781
1572852
1703923
1834994
1966065
2097136
2228207
2359278
2490349
2621420
2752491
2883562
3000000
从上面可以看出几点:
改进后的服务器端:
/**
* @author 大忽悠
*/
public class WriteServer {
private static ServerSocketChannel ssc;
private static Selector selector;
/**
* 建立连接
*/
public static void buildConnection()
{
try {
ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ssc.bind(new InetSocketAddress(18080));
selector = Selector.open();
ssc.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException
{
buildConnection();
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);
}
}
}
}
}
}
服务器:
实际写入字节:4849627
实际写入字节:3014633
实际写入字节:3145704
实际写入字节:11009964
实际写入字节:4718556
实际写入字节:2490349
实际写入字节:771167
客户端:
true
131071
262142
393213
524284
...
29817802
29948873
30000000
为何注册写事件,何时注册写事件,为什么写完之后要取消注册写事件。
如果有channel在Selector上注册了SelectionKey.OP_WRITE事件,在调用selector.select();时,系统会检查内核写缓冲区是否可写(什么时候是不可写的呢,比如缓冲区已满,channel调用了shutdownOutPut等等),如果可写,selector.select();立即返回,随后进入key.isWritable()分支。
当然你在channel上可以直接调用write(…),也可以将数据发送出去,但这样不够灵活,而且可能浪费CPU。
//不使用事件,缺点是,程序运行到这会等到200M文件发送完成后才继续往下执行,不符合异步事件模型
//的编程思想,如果缓冲区一直处于不可写状态,那么该过程一直在这里死循环,浪费了CPU资源。
ByteBuffer buffer = .... //200M的Buffer
while(buffer.hasRemaining()) {
//该方法只会写入小于socket's output buffer空闲区域的任何字节数
//并返回写入的字节数,可能是0字节。
channel.write(buffer);
}
//使用事件的方式,谁好谁坏,一看便知
if(key.isReadable()) {
ByteBuffer buffer = .... //200M的Buffer
//注册写事件
key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
//绑定Buffer
key.attach(buffer);
}
//isWritable分支
if(key.isWritable()) {
ByteBuffer buffer = (ByteBuffer) key.attachment();
SocketChannel channel = (SocketChannel) key.channel();
if (buffer.hasRemaining()) {
channel.write(buffer)
} else {
key.attach(null);
//发送完了就取消写事件,否则下次还会进入该分支
key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
}
}
注:write事件除了用上面的方法key.attach(buffer)带buffer内容给handler外,还可以直接在用channel.register方法的第三个参数attach携带要写的内容。当注册了写事件,并携带了要写的内容后,会在可写事件发生被select出来时,通过key.attachment()拿出携带的要写的内容,进行写处理。
客户端开发的一般步骤:
//打开选择器
Selector selector = Selector.open();
//打开通道
SocketChannel socketChannel = SocketChannel.open();
//配置非阻塞模型
socketChannel.configureBlocking(false);
//连接远程主机
socketChannel.connect(new InetSocketAddress("127.0.0.1",8080));
//注册事件
socketChannel.register(selector, SelectionKey.OP_CONNECT | SelectionKey.OP_READ);
//循环处理
while (true) {
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iter = keys.iterator();
while(iter.hasNext()) {
SelectionKey key = iter.next();
if(key.isConnectable()) {
//连接建立或者连接建立不成功
SocketChannel channel = (SocketChannel) key.channel();
//完成连接的建立
if(channel.finishConnect()) {
}
}
if(key.isReadable()) {
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(500 * 1024 * 1024);
buffer.clear();
channel.read(buffer);
//buffer Handler
}
iter.remove();
}
}
起初对OP_CONNECT事件还有finishConnect不理解,OP_CONNECT事件何时触发,特别是为什么要在key.isConnectable()分支里调用finishConnect方法后才能进行读写操作。
首先,在non-blocking模式下调用socketChannel.connect(new InetSocketAddress(“127.0.0.1”,8080));连接远程主机,如果连接能立即建立就像本地连接一样,该方法会立即返回true,否则该方法会立即返回false,然后系统底层进行三次握手建立连接。
连接有两种结果,一种是成功连接,第二种是异常,但是connect方法已经返回,无法通过该方法的返回值或者是异常来通知用户程序建立连接的情况,所以由OP_CONNECT事件和finishConnect方法来通知用户程序。
不管系统底层三次连接是否成功,selector都会被唤醒继而触发OP_CONNECT事件,如果握手成功,并且该连接未被其他线程关闭,finishConnect会返回true,然后就可以顺利的进行channle读写。如果网络故障,或者远程主机故障,握手不成功,用户程序可以通过finishConnect方法获得底层的异常通知,进而处理异常。
现在都是多核 cpu,设计时要充分考虑别让 cpu 的力量被白白浪费
前面的代码只有一个选择器,没有充分利用多核 cpu,如何改进呢?
分两组选择器
旧模式:
新模式
从上图可以看出,Boss线程只负责建立客户端连接,建立后,由工作线程来处理客户端的数据读写事件的监听
工作线程的数量一般控制在cpu核心数大小左右,并且每个工作线程对应一个Selector,负责监听注册在自己选择器上面的所有客户端的读写事件
写代码前,需要注意下面几点:
服务端代码实现:
import lombok.extern.slf4j.Slf4j;
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;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;
import static dhy.com.ByteBufferUtil.debugAll;
/**
* @author DHY
*/
public class ChannelDemo7
{
public static void main(String[] args) throws IOException
{
//启动Boss线程接收客户端的连接
new BossEventLoop().register();
}
@Slf4j
static class BossEventLoop implements Runnable
{
/**
* boss线程选择器,用于接收客户端的连接
*/
private Selector boss;
/**
* 工作线程
*/
private WorkerEventLoop[] workers;
/**
* 服务端Boss线程是否启动
*/
private volatile boolean start = false;
/**
* 轮询计数
*/
AtomicInteger index = new AtomicInteger();
public void register() throws IOException
{
//防止服务端重复启动
if (!start)
{
//创建一个ServerSocketChannel通道
ServerSocketChannel ssc = ServerSocketChannel.open();
//绑定端口
ssc.bind(new InetSocketAddress(8080));
//设置为非阻塞
ssc.configureBlocking(false);
//创建选择器
boss = Selector.open();
//当前ServerSocketChannel通道注册到Boss选择器上
SelectionKey ssckey = ssc.register(boss, 0, null);
//服务端通道用来接收客户端的连接
ssckey.interestOps(SelectionKey.OP_ACCEPT);
//初始化工作线程
workers = initEventLoops();
//启动Boss线程,来接收客户端的连接请求
new Thread(this, "boss").start();
log.debug("boss start...");
//请求成功,设置标记
start = true;
}
}
public WorkerEventLoop[] initEventLoops() {
//可以通过api来获取系统核心线程数,将工作线程大小设置为核心线程数量
// EventLoop[] eventLoops = new EventLoop[Runtime.getRuntime().availableProcessors()];
//由于上面api存在一定的bug,因此下面手动设置工作线程数量
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选择器阻塞接收客户端连接请求
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;
}
/**
* @param sc Boss选择器监听到客户端连接事件后,会把客户端对象传入,让当前工作线程监听其后续的读写事件并做处理
* @throws IOException
*/
public void register(SocketChannel sc) throws IOException
{
//TODO:这里存在select方法和register方法执行先后顺序的问题
//如果当前工作线程还没有初始化,就进行初始化操作
if (!start) {
//创建选择器
worker = Selector.open();
//启动工作线程---这里存在select先执行还是register先执行的问题
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();
}
});
//唤醒select阻塞住的线程---为了解决上述问题
worker.wakeup();
}
@Override
public void run() {
while (true) {
try {
//监听事件
worker.select();
//获取队列头部的任务,如果没有任务,返回null
Runnable task = tasks.poll();
//如果任务存在,执行任务
//这里因为select方法先执行,因此执行的任务里面才有register---->selectNow
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();
}
}
}
}
}
NIO中的Selector封装了底层的系统调用,其中wakeup用于唤醒阻塞在select方法上的线程,它的实现很简单,在linux上就是创建一 个管道并加入poll的fd集合,wakeup就是往管道里写一个字节,那么阻塞的poll方法有数据可读就立即返回。
wakeup方法的API还告诉我们,如果当前Selector没有阻塞在select方法上,那么本次 wakeup调用会在下一次select阻塞的时候生效,这个道理很简单,wakeup方法写入一个字节,下次poll等待的时候立即发现可读并返回,因 此不会阻塞。
首先启动服务器端
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 |
+--------+-------------------------------------------------+----------------+
同步阻塞、同步非阻塞、同步多路复用、异步阻塞(没有此情况)、异步非阻塞
当调用一次 channel.read 或 stream.read 后,会切换至操作系统内核态来完成真正数据读取,而读取又分为两个阶段,分别为:
用户线程调用read方法读取数据的时候,进而调用os的read方法,os发现数据还没到达,陷入等待,此时用户线程也需要陷入等待,此时不会占用cpu,这就是我们说的阻塞
非阻塞指的就是用户线程调用read方法询问操作系统是否有数据的时候,如果没有数据就直接返回,不会阻塞住
非阻塞体现在等待无数据直接返回上,一旦有了数据,复制数据的过程还是会阻塞住
非阻塞IO的性能不一定就比阻塞IO好,因为非阻塞IO涉及多次用户空间和系统内核空间的切换
从上图可以看出,多路复用在等待事件和复制数据的过程都需要阻塞,还比阻塞IO多了一次内核与用户空间的切换,这样一看,多路复用的性能还比较差,那么多路复用的优势体现在哪里呢?
select会得到发生的一批事件,将多个事件在select结束时,一并返回
不太常用,这里不展开
同步阻塞,同步非阻塞,多路复用都是同步的,因为都是同一个线程去要结果,同一个线程去拿回来结果
同步阻塞、同步非阻塞、同步多路复用、异步阻塞(没有此情况)、异步非阻塞
异步情况下,没有阻塞之说,异步都是非阻塞,对于异步操作来说,一般都是一个线程根操作系统打个招呼,说数据来了,麻烦送给我,然后操作系统再数据来了的时候,开辟一个线程去送数据,而最开始的线程通过回调函数可以获取到操作系统返回的数据
UNIX 网络编程 - 卷 I
传统的 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);
内部工作流程是这样的:
DMA 也可以理解为硬件单元,用来解放 cpu 完成文件 IO
可以看到中间环节较多,java 的 IO 实际不是物理设备级别的读写,而是缓存的复制,底层的真正读写是操作系统来完成的
通过 DirectByteBuf
大部分步骤与优化前相同,不再赘述。唯有一点:java 可以使用 DirectByteBuf 将堆外内存映射到 jvm 内存中来直接访问使用
进一步优化(底层采用了 linux 2.1 后提供的 sendFile 方法),java 中对应着两个 channel 调用 transferTo/transferFrom 方法拷贝数据
可以看到
进一步优化(linux 2.4)
整个过程仅只发生了一次用户态与内核态的切换,数据拷贝了 2 次。所谓的【零拷贝】,并不是真正无拷贝,而是在不会拷贝重复数据到 jvm 内存中,零拷贝的优点有
AIO 用来解决数据复制阶段的阻塞问题
异步模型需要底层操作系统(Kernel)提供支持
先来看看 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, buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
//读取的字节数和附件
public void completed(Integer result, ByteBuffer attachment) {
log.debug("read completed...{}", result);
attachment.flip();
debugAll(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();
}
}
结果
16:39:01.559 [main] DEBUG dhy.com.AioDemo1 - begin...
16:39:01.563 [main] DEBUG dhy.com.AioDemo1 - do other things...
16:39:01.563 [Thread-12] DEBUG dhy.com.AioDemo1 - read completed...2
16:39:01.576 [Thread-12] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [2]
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 64 61 |da |
+--------+-------------------------------------------------+----------------+
可以看到
默认文件 AIO 使用的线程都是守护线程,所以最后要执行 System.in.read()
以避免守护线程意外结束
package dhy.com;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.Charset;
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();
}
}
}