Netty之旅：你想要的NIO知识点，这里都有(1)

最新推荐文章于 2024-06-24 15:49:27 发布

2401_84436095

最新推荐文章于 2024-06-24 15:49:27 发布

阅读量1k

点赞数 20

分类专栏：程序员文章标签： nio 网络服务器

本文链接：https://blog.csdn.net/2401_84436095/article/details/138293540

版权

程序员专栏收录该内容

169 篇文章 0 订阅

订阅专栏

Netty之旅：你想要的NIO知识点，这里都有

NIO 方式适用于连接数目多且连接比较短(轻操作)的架构，比如聊天服务器，并发局限于应用中，编程复杂，JDK1.4 开始支持。同时，NIO和普通IO的区别主要可以从存储数据的载体、是否阻塞等来区分：

Netty之旅：你想要的NIO知识点，这里都有

Java AIO

============

与 NIO 不同，当进行读写操作时，只须直接调用 API 的 read 或 write 方法即可。这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入 read 方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将 write 方法传递的流写入完毕时，操作系统主动通知应用程序。即可以理解为，read/write 方法都是异步的，完成后会主动调用回调函数。在 JDK7 中，提供了异步文件通道和异步套接字通道的实现，这部分内容被称作 NIO.

AIO 方式使用于连接数目多且连接比较长(重操作)的架构，比如相册服务器，充分调用 OS 参与并发操作，编程比较复杂，JDK7 开始支持。

目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。

二、NIO核心组件介绍

===============

1. Channel

===============

在NIO中，基本所有的IO操作都是从Channel开始的，Channel通过Buffer(缓冲区)进行读写操作。

read()表示读取通道中数据到缓冲区，write()表示把缓冲区数据写入到通道。

Netty之旅：你想要的NIO知识点，这里都有

Channel有好多实现类，这里有三个最常用：

SocketChannel：一个客户端发起TCP连接的Channel
ServerSocketChannel：一个服务端监听新连接的TCP Channel，对于每一个新的Client连接，都会建立一个对应的SocketChannel
FileChannel：从文件中读写数据

其中SocketChannel和ServerSocketChannel是网络编程中最常用的，一会在最后的示例代码中会有讲解到具体用法。

2. Buffer

==============

概念

======

Buffer也被成为内存缓冲区，本质上就是内存中的一块，我们可以将数据写入这块内存，之后从这块内存中读取数据。也可以将这块内存封装成NIO Buffer对象，并提供一组常用的方法，方便我们对该块内存进行读写操作。

Buffer在java.nio中被定义为抽象类：

Netty之旅：你想要的NIO知识点，这里都有

我们可以将Buffer理解为一个数组的封装，我们最常用的ByteBuffer对应的数据结构就是byte[]

属性

======

Buffer中有4个非常重要的属性：capacity、limit、position、mark

Netty之旅：你想要的NIO知识点，这里都有

capacity属性：容量，Buffer能够容纳的数据元素的最大值，在Buffer初始化创建的时候被赋值，而且不能被修改。

Netty之旅：你想要的NIO知识点，这里都有

上图中，初始化Buffer的容量为8（图中从0~7，共8个元素），所以capacity = 8

limit属性：代表Buffer可读可写的上限。写模式下：limit 代表能写入数据的上限位置，这个时候limit = capacity

读模式下：在Buffer完成所有数据写入后，通过调用flip()方法，切换到读模式，此时limit等于Buffer中实际已经写入的数据大小。因为Buffer可能没有被写满，所以limit<=capacity

position属性：代表读取或者写入Buffer的位置。默认为0。写模式下：每往Buffer中写入一个值，position就会自动加1，代表下一次写入的位置。读模式下：每往Buffer中读取一个值，position就自动加1，代表下一次读取的位置。

Netty之旅：你想要的NIO知识点，这里都有

从上图就能很清晰看出，读写模式下capacity、limit、position的关系了。

mark属性：代表标记，通过mark()方法，记录当前position值，将position值赋值给mark，在后续的写入或读取过程中，可以通过reset()方法恢复当前position为mark记录的值。

这几个重要属性讲完，我们可以再来回顾下：

0 <= mark <= position <= limit <= capacity

现在应该很清晰这几个属性的关系了~

Buffer常见操作

==============

创建Buffer

============

allocate(int capacity)

ByteBuffer buffer = ByteBuffer.allocate(1024);

int count = channel.read(buffer);

例子中创建的ByteBuffer是基于堆内存的一个对象。

wrap(array)

wrap方法可以将数组包装成一个Buffer对象:

ByteBuffer buffer = ByteBuffer.wrap(“hello world”.getBytes());

channel.write(buffer);

allocateDirect(int capacity)

通过allocateDirect方法也可以快速实例化一个Buffer对象，和allocate很相似，这里区别的是allocateDirect创建的是基于堆外内存的对象。

堆外内存不在JVM堆上，不受GC的管理。堆外内存进行一些底层系统的IO操作时，效率会更高。

Buffer写操作

=============

Buffer写入可以通过put()和channel.read(buffer)两种方式写入。

通常我们NIO的读操作的时候，都是从Channel中读取数据写入Buffer，这个对应的是Buffer的写操作。

Buffer读操作

=============

Buffer读取可以通过get()和channel.write(buffer)两种方式读入。

还是同上，我们对Buffer的读入操作，反过来说就是对Channel的写操作。读取Buffer中的数据然后写入Channel中。

Netty之旅：你想要的NIO知识点，这里都有

其他常见方法

==========

rewind()：重置position位置为0，可以重新读取和写入buffer，一般该方法适用于读操作，可以理解为对buffer的重复读。

public final Buffer rewind() {

position = 0;

mark = -1;

return this;

}

flip()：很常用的一个方法，一般在写模式切换到读模式的时候会经常用到。也会将position设置为0，然后设置limit等于原来写入的position。

public final Buffer flip() {

limit = position;

position = 0;

mark = -1;

return this;

}

clear()：重置buffer中的数据，该方法主要是针对于写模式，因为limit设置为了capacity，读模式下会出问题。

public final Buffer clear() {

position = 0;

limit = capacity;

mark = -1;

return this;

}

mark()&reset(): mark()方法是保存当前position到变量markz中，然后通过reset()方法恢复当前position为mark，实现代码很简单，如下：

public final Buffer mark() {

mark = position;

return this;

}

public final Buffer reset() {

int m = mark;

if (m < 0)

throw new InvalidMarkException();

position = m;

return this;

}

常用的读写方法可以用一张图总结一下：

Netty之旅：你想要的NIO知识点，这里都有

3. Selector

================

概念

======

Selector是NIO中最为重要的组件之一，我们常常说的多路复用器就是指的Selector组件。

Selector组件用于轮询一个或多个NIO Channel的状态是否处于可读、可写。通过轮询的机制就可以管理多个Channel，也就是说可以管理多个网络连接。

Netty之旅：你想要的NIO知识点，这里都有

轮询机制

========

首先，需要将Channel注册到Selector上，这样Selector才知道需要管理哪些Channel
接着Selector会不断轮询其上注册的Channel，如果某个Channel发生了读或写的时间，这个Channel就会被Selector轮询出来，然后通过SelectionKey可以获取就绪的Channel集合，进行后续的IO操作。

Netty之旅：你想要的NIO知识点，这里都有

属性操作

========

创建Selector

通过open()方法，我们可以创建一个Selector对象。

Selector selector = Selector.open();

注册Channel到Selector中

我们需要将Channel注册到Selector中，才能够被Selector管理。

channel.configureBlocking(false);

SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

某个Channel要注册到Selector中，那么该Channel必须是非阻塞，所有上面代码中有个configureBlocking()的配置操作。

在register(Selector selector, int interestSet)方法的第二个参数，标识一个interest集合，意思是Selector对哪些事件感兴趣，可以监听四种不同类型的事件：

public static final int OP_READ = 1 << 0;

public static final int OP_WRITE = 1 << ;

public static final int OP_CONNECT = 1 << 3;

public static final int OP_ACCEPT = 1 << 4;

Connect事件：连接完成事件( TCP 连接 )，仅适用于客户端，对应 SelectionKey.OP_CONNECT。
Accept事件：接受新连接事件，仅适用于服务端，对应 SelectionKey.OP_ACCEPT 。
Read事件：读事件，适用于两端，对应 SelectionKey.OP_READ ，表示 Buffer 可读。
Write事件：写时间，适用于两端，对应 SelectionKey.OP_WRITE ，表示 Buffer 可写。

Channel触发了一个事件，表明该时间已经准备就绪：

一个Client Channel成功连接到另一个服务器，成为“连接就绪”
一个Server Socket准备好接收新进入的接，称为“接收就绪”
一个有数据可读的Channel，称为“读就绪”
一个等待写数据的Channel，称为”写就绪“

当然，Selector是可以同时对多个事件感兴趣的，我们使用或运算即可组合多个事件：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

Selector其他一些操作

==================

选择Channel

=============

public abstract int select() throws IOException;

public abstract int select(long timeout) throws IOException;

public abstract int selectNow() throws IOException;

当Selector执行select()方法就会产生阻塞，等到注册在其上的Channel准备就绪就会立即返回，返回准备就绪的数量。

select(long timeout)则是在select()的基础上增加了超时机制。

selectNow()立即返回，不产生阻塞。

有一点非常需要注意： select 方法返回的 int 值，表示有多少 Channel 已经就绪。

自上次调用select 方法后有多少 Channel 变成就绪状态。如果调用 select 方法，因为有一个 Channel 变成就绪状态则返回了 1 ；

若再次调用 select 方法，如果另一个 Channel 就绪了，它会再次返回1。

获取可操作的Channel

=================

Set selectedKeys = selector.selectedKeys();

当有新增就绪的Channel，调用select()方法，就会将key添加到Set集合中。

三、代码示例

==========

前面铺垫了这么多，主要是想让大家能够看懂NIO代码示例，也方便后续大家来自己手写NIO 网络编程的程序。创建NIO服务端的主要步骤如下：

1. 打开ServerSocketChannel，监听客户端连接 2. 绑定监听端口，设置连接为非阻塞模式 3. 创建Reactor线程，创建多路复用器并启动线程 4. 将ServerSocketChannel注册到Reactor线程中的Selector上，监听ACCEPT事件 5. Selector轮询准备就绪的key 6. Selector监听到新的客户端接入，处理新的接入请求，完成TCP三次握手，建立物理链路 7. 设置客户端链路为非阻塞模式 8. 将新接入的客户端连接注册到Reactor线程的Selector上，监听读操作，读取客户端发送的网络消息 9. 异步读取客户端消息到缓冲区 10.对Buffer编解码，处理半包消息，将解码成功的消息封装成Task 11.将应答消息编码为Buffer，调用SocketChannel的write将消息异步发送给客户端

NIOServer.java ：

public class NIOServer {

private static Selector selector;

public static void main(String[] args) {

init();

listen();

}

private static void init() {

ServerSocketChannel serverSocketChannel = null;

try {

selector = Selector.open();

serverSocketChannel = ServerSocketChannel.open();

serverSocketChannel.configureBlocking(false);

serverSocketChannel.socket().bind(new InetSocketAddress(9000));

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

System.out.println(“NioServer 启动完成”);

} catch (IOException e) {

e.printStackTrace();

}

private static void listen() {

while (true) {

try {

selector.select();

Iterator keysIterator = selector.selectedKeys().iterator();

while (keysIterator.hasNext()) {

SelectionKey key = keysIterator.next();

keysIterator.remove();

handleRequest(key);

}

} catch (Throwable t) {

t.printStackTrace();

}

private static void handleRequest(SelectionKey key) throws IOException {

SocketChannel channel = null;

try {

if (key.isAcceptable()) {

ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();

channel = serverSocketChannel.accept();

channel.configureBlocking(false);

System.out.println(“接受新的 Channel”);

channel.register(selector, SelectionKey.OP_READ);

}

if (key.isReadable()) {

channel = (SocketChannel) key.channel();

ByteBuffer buffer = ByteBuffer.allocate(1024);

int count = channel.read(buffer);

if (count > 0) {

System.out.println(“服务端接收请求：” + new String(buffer.array(), 0, count));

channel.register(selector, SelectionKey.OP_WRITE);

}

if (key.isWritable()) {

ByteBuffer buffer = ByteBuffer.allocate(1024);

buffer.put(“收到”.getBytes());

buffer.flip();

channel = (SocketChannel) key.channel();

channel.write(buffer);

channel.register(selector, SelectionKey.OP_READ);

}

} catch (Throwable t) {

t.printStackTrace();

if (channel != null) {

channel.close();

}

web浏览器中的javascript

客户端javascript
在html里嵌入javascript
javascript程序的执行
兼容性和互用性
可访问性
安全性
客户端框架
开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

window对象

计时器
浏览器定位和导航
浏览历史
浏览器和屏幕信息
对话框
错误处理
作为window对象属性的文档元素

2401_84436095

关注

20
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Netty之旅：你想要的NIO知识点，这里都有(1)

这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入 read 方法的缓冲区，并通知应用程序；接着Selector会不断轮询其上注册的Channel，如果某个Channel发生了读或写的时间，这个Channel就会被Selector轮询出来，然后通过SelectionKey可以获取就绪的Channel集合，进行后续的IO操作。NIO 方式适用于连接数目多且连接比较短(轻操作)的架构，比如聊天服务器，并发局限于应用中，编程复杂，JDK1.4 开始支持。
复制链接

扫一扫