Netty P1 NIO 基础，网络编程

Netty P1 NIO 基础，网络编程

教程地址：https://www.bilibili.com/video/BV1py4y1E7oA

https://nyimac.gitee.io/2021/04/25/Netty%E5%9F%BA%E7%A1%80/

1. 三大组件

1.1 Channel & Buffer

Channel 类似 Stream，它是读写数据的双向通道，可以从 Channel 将数据读入到 Buffer，也可以将 Buffer 的数据写入到 Channel 中；而 Stream 要么是输入，要么是输出。

常见的 Channel：

  • FileChannel
  • DatagramChannel
  • SocketChannel
  • ServerSocketChannel

Buffer 用来缓冲读写数据，常见的 Buffer：

  • ByteBuffer
    • MappedByteBuffer
    • DirectByteBuffer
    • HeapByteBuffer
  • ShortBuffer
  • IntBuffer
  • LongBuffer
  • FloatBuffer
  • DoubleBuffer
  • CharBuffer

在这里插入图片描述

1.2 Selector

在这里插入图片描述
Selector 的作用就是配合一个线程来管理多个 Channel，获取这些 Channel 上发生的事件，这些 Channel 工作在非阻塞模式下，不会让线程吊死在一个 Channel 上。适合连接数特别多，但流量低的场景。

调用 Selector 的 select() 会阻塞直到 Channel 发生了读写就绪事件，这些事件发生，select 方法就会返回这些事件交给 Thread 来处理。

2. ByteBuffer

2.1 基本使用

  1. 向 Buffer 中写入数据，例如调用 channel.read(buffer)。
  2. 调用 buffer.filp() 切换至读模式。
  3. 从 buffer 读取数据，例如调用 buffer.get()。
  4. 调用 buffer.clear() 或者 buffer.compact() 切换至写模式。
  5. 重复 1~4 步骤。
@Slf4j
public class TestByteBuffer {public static void main(String[] args) {// FileChannel// 1. 输入输出流try (FileChannel channel = new FileInputStream("data.txt").getChannel()) {// 准备缓冲区ByteBuffer buffer = ByteBuffer.allocate(10);// 从 Channel 读取数据，向 buffer 写入while (true) {int len = channel.read(buffer);log.debug("读取到的字节数量 {}", len);if (len == -1) {break;}// 切换读模式buffer.flip();while (buffer.hasRemaining()) { // 是否还有剩余未读数据byte b = buffer.get();log.debug("读取到字节 {}", (char) b);}// 切换至写模式buffer.clear();}} catch (IOException e) {throw new RuntimeException(e);}}
}

在这里插入图片描述

2.2 结构

ByteBuffer 重要属性：

  • capacity：缓冲区的容量。通过构造函数赋予，一旦设置，无法更改。
  • position：下一个读写位置的索引（类似PC）。缓冲区的位置不能为负，并且不能大于 limit。
  • limit：缓冲区的界限。位于limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。
  • mark：记录当前 position 的值。position 被改变后，可以通过调用 reset() 方法恢复到 mark 的位置。

以上四个属性必须满足以下要求：
mark <= position <= limit <= capacity

初始状态：
在这里插入图片描述

写模式下，position 是写入位置，limit 等于容量，下图表示写入了 4 个字节后的状态：
在这里插入图片描述

flip 动作发生后，position 切换为读取位置，limit 切换为读取限制：
在这里插入图片描述

读取 4 个字节后，状态：
在这里插入图片描述

clear 动作发生后，状态：
在这里插入图片描述
compact 方法，是把未读完的部分向前压缩，然后切换至写模式：
在这里插入图片描述

2.3 方法演示

ByteBufferUtil 工具类
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 paddingsfor (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(StringUtil.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 conversionfor (i = 0; i < BYTE2HEX.length; i++) {BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);}// Generate the lookup table for byte dump paddingsfor (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 conversionfor (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 (MathUtil.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("         +-------------------------------------------------+" +StringUtil.NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +StringUtil.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 dumpint rowEndIndex = rowStartIndex + 16;for (int j = rowStartIndex; j < rowEndIndex; j++) {dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);}dump.append(" |");// ASCII dumpfor (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 dumpint rowEndIndex = rowStartIndex + remainder;for (int j = rowStartIndex; j < rowEndIndex; j++) {dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);}dump.append(HEXPADDING[remainder]);dump.append(" |");// Ascii dumpfor (int j = rowStartIndex; j < rowEndIndex; j++) {dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);}dump.append(BYTEPADDING[remainder]);dump.append('|');}dump.append(StringUtil.NEWLINE +"+--------+-------------------------------------------------+----------------+");}private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {if (row < HEXDUMP_ROWPREFIXES.length) {dump.append(HEXDUMP_ROWPREFIXES[row]);} else {dump.append(StringUtil.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);}
}
2.3.1 put 方法

用于向 Buffer 中写数据：

public class TestByteBufferReadWrite {public static void main(String[] args) {ByteBuffer buffer = ByteBuffer.allocate(10);buffer.put((byte) 0x61); // 'a'ByteBufferUtil.debugAll(buffer);buffer.put(new byte[]{'b', 'c', 'd'});ByteBufferUtil.debugAll(buffer);buffer.flip();System.out.println(buffer.get());ByteBufferUtil.debugAll(buffer);buffer.compact();ByteBufferUtil.debugAll(buffer);buffer.put(new byte[]{'e', 'f'});ByteBufferUtil.debugAll(buffer);}
}

+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [10]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 00 00 00 00 00 00 00 00 00                   |a.........      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [4], limit: [10]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
97
+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [4]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [3], limit: [10]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
// compact 后下标为 3 的 position 位置的数据并不会清空，因为切换为写模式，写入的时候会直接覆盖
|00000000| 62 63 64 64 00 00 00 00 00 00                   |bcdd......      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [5], limit: [10]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 62 63 64 65 66 00 00 00 00 00                   |bcdef.....      |
+--------+-------------------------------------------------+----------------+
2.3.2 分配空间 allocate
public class TestByteBufferReadWrite {public static void main(String[] args) {System.out.println(ByteBuffer.allocate(10).getClass());System.out.println(ByteBuffer.allocateDirect(10).getClass());}
}

class java.nio.HeapByteBuffer
class java.nio.DirectByteBuffer
  • java.nio.HeapByteBuffer：java 堆内存，读写效率较低，收到 GC 的影响
  • java.nio.DirectByteBuffer：直接内存，读写效率高（少一次拷贝），不会受到 GC 的影响，分配效率低（因为要调用操作系统的方法），可能会造成内存泄漏
2.3.3 向 Buffer 写入数据
  • 调用 channel 的 read 方法：
  • 调用 buffer 自己的 put 方法
int len = channel.read(buffer); // 将 channel 内的数据读取到 buffer 中
buffer.put((byte) 127);
2.3.4 从 Buffer 读取数据
  • 调用 channel 的 write 方法
  • 调用 buffer 自己的 get 方法
int len = channel.write(buffer); // 将 buffer 中的内容写入到 channel 中
byte b = buffer.get();

get 方法会让 position 读指针向后走，如果想重复读取数据：

  • 可以调用 rewind 方法将 position 重新置为 0
  • 或者调用 get(int i) 方法获取索引 i 的内容，它不会移动读指针

rewind() 使用：

public class TestByteBufferRead {public static void main(String[] args) {ByteBuffer buffer = ByteBuffer.allocate(10);buffer.put("abcd".getBytes());buffer.flip(); // 切换到读模式// rewind 从头开始读buffer.get(new byte[buffer.limit()]);ByteBufferUtil.debugAll(buffer);buffer.rewind();System.out.println((char) buffer.get());}
}

在这里插入图片描述

get(int i) 使用：

public class TestByteBufferRead {public static void main(String[] args) {ByteBuffer buffer = ByteBuffer.allocate(10);buffer.put("abcd".getBytes());buffer.flip(); // 切换到读模式System.out.println((char) buffer.get(3));ByteBufferUtil.debugAll(buffer);}
}

在这里插入图片描述

2.3.5 mark 和 reset

mark 做一个标记，记录 position 的位置，reset 是将 position 的位置重置到 mark 的位置。

public class TestByteBufferRead {public static void main(String[] args) {ByteBuffer buffer = ByteBuffer.allocate(10);buffer.put("abcd".getBytes());buffer.flip(); // 切换到读模式System.out.println((char) buffer.get());System.out.println((char) buffer.get());buffer.mark(); // 记录当前的position的值 2System.out.println((char) buffer.get());System.out.println((char) buffer.get());buffer.reset();//  将 position 置回到 2 这个位置System.out.println((char) buffer.get());System.out.println((char) buffer.get());}
}

在这里插入图片描述

2.3.6 字符串和 ByteBuffer 相互转换
public class TestByteBufferString {public static void main(String[] args) {// 1. 字符串转为 ByteBuffer, 使用后默认还是写模式ByteBuffer buffer1 = ByteBuffer.allocate(16);buffer1.put("hello".getBytes());ByteBufferUtil.debugAll(buffer1);// 2. Charset，使用后直接切换为读模式ByteBuffer buffer2 = StandardCharsets.UTF_8.encode("hello");ByteBufferUtil.debugAll(buffer2);// 3. wrap，使用后直接切换为读模式ByteBuffer buffer3 = ByteBuffer.wrap("hello".getBytes());ByteBufferUtil.debugAll(buffer3);// 4. Charset decode 将 buffer 转换为字符串String str1 = StandardCharsets.UTF_8.decode(buffer2).toString();System.out.println(str1);// 5. 因为没切换到读模式，所以什么都读取不到String str2 = StandardCharsets.UTF_8.decode(buffer1).toString();System.out.println(str2);}
}

+--------+-------------------- all ------------------------+----------------+
position: [5], limit: [16]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 |hello...........|
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [5]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f                                  |hello           |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [0], limit: [5]+-------------------------------------------------+|  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f                                  |hello           |
+--------+-------------------------------------------------+----------------+
hello

2.4 分散读，集中取

2.4.1 分散读

分散读取，有一个文本文件 words.txt

onetwothree

public class TestScatteringReads {public static void main(String[] args) {try (FileChannel channel = new RandomAccessFile("words.txt", "r").getChannel()) {ByteBuffer b1 = ByteBuffer.allocate(3);ByteBuffer b2 = ByteBuffer.allocate(3);ByteBuffer b3 = ByteBuffer.allocate(5);channel.read(new ByteBuffer[]{b1, b2, b3});b1.flip();b2.flip();b3.flip();ByteBufferUtil.debugAll(b1);ByteBufferUtil.debugAll(b2);ByteBufferUtil.debugAll(b3);} catch (IOException e) {throw new RuntimeException(e);}}
}

在这里插入图片描述

2.4.2 集中写
public class TestGatheringWrites {public static void main(String[] args) {ByteBuffer b1 = StandardCharsets.UTF_8.encode("hello");ByteBuffer b2 = StandardCharsets.UTF_8.encode("hello");ByteBuffer b3 = StandardCharsets.UTF_8.encode("你好");try (FileChannel channel = new RandomAccessFile("words2.txt", "rw").getChannel()) {channel.write(new ByteBuffer[]{b1, b2, b3});} catch (IOException e) {throw new RuntimeException(e);}}
}

在这里插入图片描述

2.5 粘包半包分析

现象

网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔，但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有 3 条为：

  • Hello,world\n
  • I’m Jack\n
  • How are you?\n

变成了下面的两个 byteBuffer (粘包，半包)

  • Hello,world\nI’m Jack\nHo
  • w are you?\n
粘包

发送方在发送数据时，并不是一条一条地发送数据，而是将数据整合在一起（增加传输效率），当数据达到一定的数量后再一起发送。这就会导致多条信息被放在一个缓冲区中被一起发送出去。

半包

接收方的缓冲区的大小是有限的，当接收方的缓冲区满了以后，就需要将信息截断，等缓冲区空了以后再继续放入数据。这就会发生一段完整的数据最后被截断的现象。

解决办法
  • 通过 get(index) 方法遍历 ByteBuffer，遇到分隔符时进行处理。注意：get(index) 不会改变 position 的值
    • 记录该段数据长度，以便于申请对应大小的缓冲区
    • 将缓冲区的数据通过 get() 方法写入到 target 中
  • 调用 compact 方法切换模式，因为缓冲区中可能还有未读的数据
public class TestByteBufferExam {public static void main(String[] args) {ByteBuffer source = ByteBuffer.allocate(32);source.put("Hello,world\nI'm Jack\nHo".getBytes());split(source);source.put("w are you?\n".getBytes());split(source);}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());}ByteBufferUtil.debugAll(target);}}source.compact();}
}

在这里插入图片描述

3. 网络编程

3.1 阻塞 vs 非阻塞

3.1.1 阻塞

在这里插入图片描述

Server：

@Slf4j
public class Server {@SneakyThrowspublic static void main(String[] args) {// 使用 nio 来理解阻塞模式，单线程// 0. ByteBufferByteBuffer 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("等待客户端连接...");SocketChannel sc = ssc.accept(); // 阻塞方法，线程停止运行，直到建立连接log.debug("客户端连接成功!!!, {}", sc);channels.add(sc);for (SocketChannel channel : channels) {// 5. 接受客户端发送的数据log.debug("等待客户端发送数据..., {}", channel);channel.read(buffer);  // 阻塞方法，线程停止运行，直到客户端发送新的数据buffer.flip();ByteBufferUtil.debugRead(buffer);buffer.clear();log.debug("客户端发送数据成功!!!, {}", channel);}}}
}

客户端：

public class Client {@SneakyThrowspublic static void main(String[] args) {SocketChannel sc = SocketChannel.open();sc.connect(new InetSocketAddress("localhost", 8080));sc.write(StandardCharsets.UTF_8.encode("hello"));System.out.println("waiting。。。。");sc.close();}
}
3.1.2 非阻塞
  • 可以通过 ServerSocketChannel 的 configureBlocking(false) 方法将获得连接设置为非阻塞的。此时若没有连接，accept 会返回 null。
  • 可以通过 SocketChannel 的 configureBlocking(false) 方法将从通道中读取数据设置为非阻塞的。若此时通道中没有数据可读，read 会返回 -1。
@Slf4j
public class Server {@SneakyThrowspublic static void main(String[] args) {// 使用 nio 来理解阻塞模式，单线程// 0. ByteBufferByteBuffer 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("等待客户端连接...");// 设置为非阻塞模式，没有连接时返回null，不会阻塞线程ssc.configureBlocking(false);SocketChannel sc = ssc.accept();if (sc != null) {log.debug("客户端连接成功!!!, {}", sc);channels.add(sc);}for (SocketChannel channel : channels) {// 5. 接受客户端发送的数据log.debug("等待客户端发送数据..., {}", channel);// 设置为非阻塞模式，若通道中没有数据，会返回0，不会阻塞线程channel.configureBlocking(false);int read = channel.read(buffer);if (read > 0) {buffer.flip();ByteBufferUtil.debugRead(buffer);buffer.clear();log.debug("客户端发送数据成功!!!, {}", channel);}}}}
}

这样写存在一个问题，因为设置为了非阻塞，会一直执行 while(true) 中的代码，CPU一直处于忙碌状态，会使得性能变低，所以实际情况中不使用这种方法处理请求。

3.1.3 Selector 处理 accept

多路复用

单线程可以配合 Selector 完成对多个 Channel 可读写事件的监控，这称之为多路复用。

  • 多路复用仅针对网络 IO，普通文件 IO 无法利用多路复用
  • 如果不用 Selector 的非阻塞模式，线程大部分时间都在做无用功，而 Selector 能够保证
    • 有可连接事件时才去连接
    • 有可读事件才去读取
    • 有可写事件才去写入（限于网络传输能力，Channel 未必时时可写，一旦 Channel 可写，会触发 Selector 的可写事件）
@Slf4j
public class Server {@SneakyThrowspublic static void main(String[] args) {// 1. 创建 selector，管理多个 channelSelector selector = Selector.open();ByteBuffer buffer = ByteBuffer.allocate(16);ServerSocketChannel ssc = ServerSocketChannel.open();ssc.configureBlocking(false);// 2. 建立 selector 和 channel 的联系（注册）// selectionKey：时间发生后，通过它可以知道事件和哪个 channel 的事件// OP_ACCEPT 表示只关注 accept 事件SelectionKey sscKey = ssc.register(selector, SelectionKey.OP_ACCEPT);log.debug("注册 key: {}", sscKey);ssc.bind(new InetSocketAddress(8080));List<SocketChannel> channels = new ArrayList<>();while (true) {// 3. select 方法，没有事件发生，线程阻塞，有事件，线程才会恢复运行// select 在事件未处理时，不会阻塞；事件发生后要么处理，要么取消，不能置之不理selector.select();// 4. 处理事件, selectedKeys 内部包含了所有发生的事件Iterator<SelectionKey> iter = selector.selectedKeys().iterator();while (iter.hasNext()) {SelectionKey key = iter.next();log.debug("key: {}", key);ServerSocketChannel channel = (ServerSocketChannel) key.channel();SocketChannel sc = channel.accept();log.debug("{}", sc);//                key.cancel();}}}
}
3.1.4 处理 read 事件
@Slf4j
public class Server {public static void main(String[] args) throws IOException {// 1. 创建 selector，管理多个 channelSelector selector = Selector.open();ServerSocketChannel ssc = ServerSocketChannel.open();ssc.configureBlocking(false);// 2. 建立 selector 和 channel 的联系（注册）// selectionKey：时间发生后，通过它可以知道事件和哪个 channel 的事件// OP_ACCEPT 表示只关注 accept 事件SelectionKey sscKey = ssc.register(selector, SelectionKey.OP_ACCEPT);log.debug("注册 key: {}", sscKey);ssc.bind(new InetSocketAddress(8080));List<SocketChannel> channels = new ArrayList<>();while (true) {// 3. select 方法，没有事件发生，线程阻塞，有事件，线程才会恢复运行// select 在事件未处理时，不会阻塞；事件发生后要么处理，要么取消，不能置之不理selector.select();// 4. 处理事件, selectedKeys 内部包含了所有发生的事件Iterator<SelectionKey> iter = selector.selectedKeys().iterator();while (iter.hasNext()) {SelectionKey key = iter.next();// 当处理完一个事件后，一定要调用迭代器的remove方法移除对应事件，否则会出现错误。iter.remove();log.debug("key: {}", key);// 5. 区分事件类型if (key.isAcceptable()) {ServerSocketChannel channel = (ServerSocketChannel) key.channel();SocketChannel sc = channel.accept();sc.configureBlocking(false);sc.register(selector, SelectionKey.OP_READ);log.debug("{}", sc);} else if (key.isReadable()) {try {SocketChannel channel = (SocketChannel) key.channel();ByteBuffer buffer = ByteBuffer.allocate(16);// 正常断开返回 -1int read = channel.read(buffer);if (read == -1) {key.cancel();} else if (read > 0) {buffer.flip();ByteBufferUtil.debugRead(buffer);buffer.clear();}} catch (IOException e) {e.printStackTrace();// 因为客户端断开了，因此需要将 key 取消（从 selector 的 keys 集合中真正删除 key）key.cancel();}}}}}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/161601.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

华为9.20笔试 复现

华为9.20笔试 复现

第一题 丢失报文的位置 思路&#xff1a;从数组最小索引开始遍历 #include <iostream> #include <vector> using namespace std; // 求最小索引值 int getMinIdx(vector<int> &arr) {int minidx 0;for (int i 0; i < arr.size(); i){if (arr[i] …
阅读更多...
【k8s总结】

【k8s总结】

资源下载&#xff1a;http://www.ziyuanwang.online/912.html Kubernetes(K8s) 一、Openstack&VM 1、认识虚拟化 1.1、什么是虚拟化 在计算机中&#xff0c;虚拟化&#xff08;英语&#xff1a;Virtualization&#xff09;是一种资源管理技术&#xff0c;是将计算机的…
阅读更多...
力扣每日一题43：字符串相乘

力扣每日一题43：字符串相乘

题目描述&#xff1a; 给定两个以字符串形式表示的非负整数 num1 和 num2&#xff0c;返回 num1 和 num2 的乘积&#xff0c;它们的乘积也表示为字符串形式。 注意&#xff1a;不能使用任何内置的 BigInteger 库或直接将输入转换为整数。 示例 1: 输入: num1 "2"…
阅读更多...
多模态及图像安全的探索与思考

多模态及图像安全的探索与思考

前言 第六届中国模式识别与计算机视觉大会&#xff08;The 6th Chinese Conference on Pattern Recognition and Computer Vision, PRCV 2023&#xff09;已于近期在厦门成功举办。通过参加本次会议&#xff0c;使我有机会接触到许多来自国内外的模式识别和计算机视觉领域的研究…
阅读更多...
【云计算网络安全】DDoS 攻击类型：什么是 ACK 洪水 DDoS 攻击

【云计算网络安全】DDoS 攻击类型：什么是 ACK 洪水 DDoS 攻击

文章目录 一、什么是 ACK 洪水 DDoS 攻击&#xff1f;二、什么是数据包&#xff1f;三、什么是 ACK 数据包&#xff1f;四、ACK 洪水攻击如何工作&#xff1f;五、SYN ACK 洪水攻击如何工作&#xff1f;六、文末送书《AWD特训营》内容简介读者对象 一、什么是 ACK 洪水 DDoS 攻…
阅读更多...
【MyBatis系列】- 什么是MyBatis

【MyBatis系列】- 什么是MyBatis

【MyBatis系列】- 什么是MyBatis 文章目录 【MyBatis系列】- 什么是MyBatis一、学习MyBatis知识必备1.1 学习环境准备1.2 学习前掌握知识二、什么是MyBatis三、持久层是什么3.1 为什么需要持久化服务3.2 持久层四、Mybatis的作用五、MyBatis的优点六、参考文档一、学习MyBatis知…
阅读更多...
JavaWeb-10月16笔记

JavaWeb-10月16笔记

JavaWeb 现实生活中的互联网项目都是javaWeb项目, 包含网络, 多线程, 展示: HTML等其他的前端技术, 界面窗体展示(Swing包,AWT包 窗体), C#,… ** JAVAWeb架构: ** - B/S: 浏览器/服务器 优点: 以浏览器作为客户端, 使用这个软件, 用户不需要下载客户端, 程序更新,不需要…
阅读更多...
2000年至2017年LandScan全球人口分布数据（1KM分辨率）

2000年至2017年LandScan全球人口分布数据（1KM分辨率）

简介&#xff1a; LandScan全球人口分布数据来自于East View Cartographic&#xff0c;由美国能源部橡树岭国家实验室(ORNL)开发。LandScan运用GIS和遥感等创新方法&#xff0c;是全球人口数据发布的社会标准&#xff0c;是全球最为准确、可靠&#xff0c;基于地理位置的&…
阅读更多...
【Overload游戏引擎细节分析】视图投影矩阵计算与摄像机

【Overload游戏引擎细节分析】视图投影矩阵计算与摄像机

本文只罗列公式&#xff0c;不做具体的推导。 OpenGL本身没有摄像机(Camera)的概念&#xff0c;但我们为了产品上的需求与编程上的方便&#xff0c;一般会抽象一个摄像机组件。摄像机类似于人眼&#xff0c;可以建立一个本地坐标系。相机的位置是坐标原点&#xff0c;摄像机的朝…
阅读更多...
AMEYA360-罗姆ROHM马来西亚工厂新厂房竣工

AMEYA360-罗姆ROHM马来西亚工厂新厂房竣工

全球知名半导体制造商罗姆为了加强模拟IC的产能&#xff0c;在其马来西亚制造子公司ROHM-Wako Electronics (Malaysia) Sdn. Bhd.(以下简称“RWEM”)投建了新厂房&#xff0c;近日新厂房已经竣工&#xff0c;并举行了竣工仪式。 RWEM此前主要生产二极管和LED等小信号产品&#…
阅读更多...
自己写spring boot starter问题总结

自己写spring boot starter问题总结

1. Unable to find main class 创建spring boot项目写自己的starterxi写完之后使用install出现Unable to find main class&#xff0c;这是因为spring boot打包需要一个启动类&#xff0c;按照以下写法就没事 <plugins><plugin><groupId>org.springframewo…
阅读更多...
二、K8S之Pods

二、K8S之Pods

Pod 一、概念 K8S作为一个容器编排管理工具&#xff0c;它可以自动化容器部署、容器扩展、容器负载均衡等任务&#xff0c;并提供容器的自愈能力等功能。在Kubernetes中&#xff0c;Pod是最基本的调度单元&#xff0c;它是一组共享存储和网络资源的容器集合&#xff0c;通常是…
阅读更多...
数字孪生与智慧城市：重塑未来城市生活的奇迹

数字孪生与智慧城市：重塑未来城市生活的奇迹

今天&#xff0c;我们将探讨数字孪生和智慧城市两个颠覆性技术&#xff0c;它们正引领着未来城市生活的巨大变革。随着科技的飞速发展&#xff0c;数字孪生和智慧城市成为实现可持续发展和提升居民生活质量的关键策略。 数字孪生&#xff1a;实现现实与虚拟的完美融合 数字孪生…
阅读更多...
使用RCurl和R来爬虫视频

使用RCurl和R来爬虫视频

以下是一个使用RCurl和R来爬虫视频的示例代码&#xff0c;代码中使用了https://www.duoip.cn/get_proxy来获取代理IP&#xff1a; # 引入必要的库 library(RCurl) library(rjson)# 获取代理IP proxy_url <- "https://www.duoip.cn/get_proxy" proxy <- getURL…
阅读更多...
Java 反射

Java 反射

目录 反射机制&#x1f6a9;一个需求引出反射&快速入门反射机制反射的扩展-反射相关类反射的优点和缺点反射调用时会造成性能的一些降低->反射调用性能优化&#xff08;虽然优化程度不高&#xff0c;但是也是可以起到适当的优化的作用&#xff09; Class类&#x1f6a9;…
阅读更多...
基于Springboot实现在线答疑平台系统项目【项目源码+论文说明】

基于Springboot实现在线答疑平台系统项目【项目源码+论文说明】

基于Springboot实现在线答疑平台系统演示 摘要 社会的发展和科学技术的进步&#xff0c;互联网技术越来越受欢迎。网络计算机的生活方式逐渐受到广大师生的喜爱&#xff0c;也逐渐进入了每个学生的使用。互联网具有便利性&#xff0c;速度快&#xff0c;效率高&#xff0c;成本…
阅读更多...
第五届芜湖机器人展，正运动助力智能装备“更快更准”更智能！

第五届芜湖机器人展，正运动助力智能装备“更快更准”更智能！

■展会名称&#xff1a; 第十一届中国(芜湖)科普产品博览交易会-第五届机器人展 ■展会日期 2023年10月21日-23日 ■展馆地点 中国ㆍ芜湖宜居国际博览中心B馆 ■展位号 B029 正运动技术&#xff0c;作为国内领先的运动控制企业&#xff0c;将于2023年10月21日参加芜湖机…
阅读更多...
《优化接口设计的思路》系列：第五篇—接口发生异常如何统一处理

《优化接口设计的思路》系列：第五篇—接口发生异常如何统一处理

系列文章导航 第一篇—接口参数的一些弯弯绕绕 第二篇—接口用户上下文的设计与实现 第三篇—留下用户调用接口的痕迹 第四篇—接口的权限控制 第五篇—接口发生异常如何统一处理 本文参考项目源码地址&#xff1a;summo-springboot-interface-demo 前言 大家好&#xff01;…
阅读更多...
如何从一门编程语言过渡到另一门编程语言？

如何从一门编程语言过渡到另一门编程语言？

在数字时代&#xff0c;软件开发领域不断进化&#xff0c;不同编程语言层出不穷。作为一位富有经验的开发者&#xff0c;你可能曾面临过一个重要的问题&#xff1a;如何顺利过渡到一门全新的编程语言&#xff1f; 这个问题不仅是对技术领域的学习&#xff0c;更是对职业生涯的…
阅读更多...
多数元素-----题解报告

多数元素-----题解报告

题目&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 这一题仔细阅读题目意思就会发现&#xff0c;主要就是找众数&#xff0c;并且题目中明确告知&#xff0c;给出的数组中必然有出现次数超过n/2的元素。 那就很简单了&#xff0c;有一…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023