Java NIO 编程:Buffer、Channel、Selector原理详解
1 Java 中的 I/O模型:BIO、NIO、AIO
1.1 BIO、NIO、AIO概念介绍
I/O 模型简单的理解:就是
用什么样的通道进行数据的发送和接收
,很大程度上决定了程序通信的性能。Java共支持3种网络编程模型/IO模式:
BIO
、NIO
、AIO
。Java BIO
:同步并阻塞(传统阻塞型)
,服务器实现模式为一个连接对应一个线程
,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销。
Java NIO
:同步非阻塞
,服务器实现模式为一个线程处理多个请求(连接)
,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求就进行处理。
Java AIO(NIO.2)
:异步非阻塞
,AIO 引入异步通道
的概念,采用了Proactor 模式
,简化了程序编写,有效的请求才启动线程
,它的特点是:先由操作系统完成后才通知服务端程序启动线程去处理,一般适用于连接数较多且连接时间较长的应用。
BIO、NIO、AIO适用场景分析
- BIO方式适用于
连接数目比较小且固定的架构
,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4以前的唯一选择,但程序简单易理解。 - NIO方式适用于
连接数目多且连接比较短(轻操作)的架构
,比如聊天服务器,弹幕系统,服务器间通讯等。编程比较复杂,JDK1.4
开始支持。 - AIO方式适用于
连接数目多且连接比较长(重操作)的架构
,比如相册服务器,充分调用OS参与并发操作,编程比较复杂
1.2 简单回顾一下 BIO 的编程流程
1.2.1 BIO编程的简单流程
- 服务器端启动一个ServerSocket;
- 客户端启动Socket对服务器进行通信,默认情况下服务器端需要对每个客户 建立一个线程与之通讯;
- 客户端发出请求后, 先咨询服务器是否有线程响应,如果没有则会等待,或者被拒绝;
- 如果有响应,
客户端线程会等待请求结束后,再继续执行
。
1.2.2 BIO 编程通信实例
实现思路:
- 创建一个线程池;
- 如果有客户端连接,就创建一个线程与之通讯(单独写一个方法)。
public class BIOServer {public static void main(String[] args) throws IOException {// 思路:// 1.创建一个线程池// 2.如果有客户端连接,就创建一个线程与之通讯(单独写一个方法)ExecutorService threadPool = Executors.newCachedThreadPool();ServerSocket serverSocket = new ServerSocket(6666);System.out.println("服务器启动了");while (true) {// 监听,等待客户端连接final Socket socket = serverSocket.accept();System.out.println("连接到一个客户端");// 创建一个线程与之通讯threadPool.execute(new Runnable() {public void run() {// 可以和客户端通讯handler(socket);}});}}// 编写一个和客户端通讯你的方法public static void handler(Socket socket) {byte[] bytes = new byte[1024];// 通过socket获取输入流try {InputStream inputStream = socket.getInputStream();// 循环读取客户端发送的数据while (true) {int read = inputStream.read(bytes);if (read != -1) {// 输出客户端发送的数据System.out.println(new String(bytes,0,read));} else { // 否则通讯结束break;}}} catch (IOException e) {e.printStackTrace();} finally {System.out.println("关闭和client的连接");try {socket.close();} catch (IOException e) {e.printStackTrace();}}}}
打开cmd,使用telnet命令连接我们自己编写的Server,
如果无法使用telnet,参考:https://jingyan.baidu.com/article/e8cdb32b433ce676052badb5.html
按下:Ctrl + ] 就能发数据了
2 Java NIO 基本介绍
2.1 NIO 基本概念
Java NIO 全称 java non-blocking IO,是指 JDK 提供的新 API。从 JDK1.4 开始,Java 提供了一系列改进的 输入/输出 的新特性,被统称为 NIO(即 New IO),是
同步非阻塞
的。NIO 相关类都被放在 java.nio 包及子包下,并且对原 java.io 包中的很多类进行改写。
NIO 有三大核心部分:
Channel(通道)
、Buffer(缓冲区)
、Selector(选择器)
NIO是
面向缓冲区
,或者面向块
编程的(因为有了 Buffer)。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动,这就增加了处理过程中的灵活性。有了缓冲区就能使用它可以提供非阻塞式的高伸缩性网络
。
Java NIO的非阻塞模式,使一个线程从某个
通道
发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。Selector(选择器)获取到通道的事件,就调用 thread 会去处理;如果这个通道没有事件了,thread 就去处理别的通道的事件;如果所有通道都没有事件了,thread 还可以去其它任务。反正thread没有阻塞。
通俗理解:NIO是可以做到用一个线程来处理多个操作的。假设有10000个请求过来,根据实际情况,可以分配50或者100个线程来处理。不像之前的阻塞IO那样,非得分配10000个。
HTTP2.0
使用了多路复用
的技术,做到同一个连接并发处理多个请求,而且并发请求的数量比HTTP1.1大了好几个数量级。
2.2 NIO 与 BIO 比较
- BIO 以
流
的方式处理数据,而 NIO 以块
的方式处理数据,块 I/O 的效率比流 I/O 高很多; - BIO 是
阻塞
的,NIO 则是非阻塞
的 - BIO基于
字节流和字符流
进行操作,而 NIO 基于Channel(通道)
和Buffer(缓冲区)
进行操作,数据总是从通道读取到缓冲区中
,或者从缓冲区写入到通道中
。Selector(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道。
2.3 NIO 三大核心组件之间的关系
每个channel 都会对应一个Buffer
;- Selector 对应一个线程, 一个线程对应多个channel(连接);
- 该图反应了有三个channel
注册到 Selector
; - 程序切换到哪个channel 是由
事件(Event)
决定的,Event 就是一个重要的概念; - Selector 会根据不同的事件,在各个通道上切换;
- Buffer 就是一个
内存块
,底层是有一个数组
; - 数据的
读取/写入
是通过Buffer
, 这个和BIO不同 , BIO 中要么是输入流
,要么是输出流
,不能双向
,但是NIO的Buffer 是可以读也可以写,但是需要flip
方法切换 读/写 状态
; - channel 是
双向
的,可以返回底层操作系统的情况
,比如Linux 底层的操作系统通道就是双向的。
3 NIO三大核心组件 之 缓冲区(Buffer)
缓冲区(Buffer):缓冲区本质上是一个可以 读写
数据的 内存块
,可以理解成是一个容器对象(含数组),该对象提供了一组方法,可以更轻松地使用内存块,缓冲区对象内置了一些机制,能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道,但是读取或写入的数据都必须经由 Buffer,如图: 【后面举例说明】
3.1 Buffer 类及其子类
在 NIO 中,Buffer 是一个顶层父类,它是一个 抽象类
,类的层级关系图:
3.2 Buffer类中的重要属性
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;
- Capacity:容量,即可以容纳的最大数据量;在缓冲区创建时被设定并且不能改变
- Limit:表示缓冲区的当前终点,不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改
- Position:位置,下一个要被读或写的元素的索引,每次读写缓冲区数据时都会改变改值,为下次读写作准备
- Mark:标记
3.3 Buffer的基本使用示例
public class BasicBuffer {public static void main(String[] args) {// 举例说明 Buffer 的使用// 创建一个 Buffer,大小为 6,可以存放 6 个 intIntBuffer intBuffer = IntBuffer.allocate(5);// 向 Buffer 中存放数据for (int i = 0; i < intBuffer.capacity(); i++) {intBuffer.put(i * 2);}// 从 Buffer 中读取数据// 将 Buffer 转换,读/写 切换 !!!intBuffer.flip();while (intBuffer.hasRemaining()) {System.out.println(intBuffer.get());}}
}
IntBuffer intBuffer = IntBuffer.allocate(5);
初始化之后,其中的属性为:
- 执行完for循环写入值之后,属性状态为,此时limit 和 position 都为5,达到上限了,读/写 数据不能超过limit的值
intBuffer.flip();
切换读
状态后,position重置为0
3.4 Buffer类相关方法一览
public abstract class Buffer {//JDK1.4时,引入的apipublic final int capacity( )//返回此缓冲区的容量public final int position( )//返回此缓冲区的位置public final Buffer position (int newPositio)//设置此缓冲区的位置public final int limit( )//返回此缓冲区的限制public final Buffer limit (int newLimit)//设置此缓冲区的限制public final Buffer mark( )//在此缓冲区的位置设置标记public final Buffer reset( )//将此缓冲区的位置重置为以前标记的位置public final Buffer clear( )//清除此缓冲区, 即将各个标记恢复到初始状态,但是数据并没public final Buffer flip( )//反转此缓冲区public final Buffer rewind( )//重绕此缓冲区public final int remaining( )//返回当前位置与限制之间的元素数public final boolean hasRemaining( )//告知在当前位置和限制之间是否有元素public abstract boolean isReadOnly( );//告知此缓冲区是否为只读缓冲区//JDK1.6时引入的apipublic abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组public abstract Object array();//返回此缓冲区的底层实现数组public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区
}
3.5 最常用的子类:ByteBuffer
从前面可以看出对于 Java 中的基本数据类型(boolean除外
),都有一个 Buffer 类型与之相对应,最 常用的自然是ByteBuffer 类(二进制数据)
,该类的主要方法如下:
public abstract class ByteBuffer {//缓冲区创建相关apipublic static ByteBuffer allocateDirect(int capacity)//创建直接缓冲区public static ByteBuffer allocate(int capacity)//设置缓冲区的初始容量public static ByteBuffer wrap(byte[] array)//把一个数组放到缓冲区中使用//构造初始化位置offset和上界length的缓冲区public static ByteBuffer wrap(byte[] array,int offset, int length)//缓存区存取相关APIpublic abstract byte get( );//从当前位置position上get,get之后,position会自动+1public abstract byte get (int index);//从绝对位置getpublic abstract ByteBuffer put (byte b);//从当前位置上添加,put之后,position会自动+1public abstract ByteBuffer put (int index, byte b);//从绝对位置上put
}
4 NIO三大核心组件 之 通道(Channel)
NIO 的通道类似于流,但有些区别如下:
- 通道可以
同时进行读写
,而流只能读或者只能写; - 通道可以实现
异步读写数据
; - 通道可以
从缓冲读数据
,也可以写数据到缓冲
。
4.1 Channel接口及其子类
Channel在NIO中是一个接口
public interface Channel extends Closeable{}
常用的 Channel 类有:FileChannel、DatagramChannel、ServerSocketChannel 和SocketChannel。
- FileChannel 用于
文件
的数据读写, - DatagramChannel 用于
UDP
的数据读写, - ServerSocketChannel 和 SocketChannel 用于
TCP
的数据读写。ServerSocketChannel
类似ServerSocket;SocketChannel
类似 Socket。
Java中ServerSocket与Socket的区别:https://blog.csdn.net/wwwjiahuan/article/details/60881489
ServerSocketChannel 和 SocketChannel的区别
ServerSocketChannel
是一个 抽象类
,我们实际使用的是 ServerSocketChannelImpl
。
SocketChannel
是一个 抽象类
,我们实际使用的是 SocketChannelImpl
。
我们首先会在服务器端创建一个ServelSocketChannel,它真实的类型是ServelSocketChannelImpl,当有一个连接来连接Server时,由ServelSocketChannel生成一个与该客户端对应的一个通道,这个通道的类型就是SocketChannel,它的真实类型是SocketChannelImpl,客户端通过这个通道与Server进行通讯。
4.2 FileChannel 类
FileChannel主要用来对本地文件进行 IO 操作,常见的方法有:
public int read(ByteBuffer dst)
,从通道读取数据并放到缓冲区中public int write(ByteBuffer src)
,把缓冲区的数据写到通道中public long transferFrom(ReadableByteChannel src, long position, long count)
,从目标通道中复制数据到当前通道public long transferTo(long position, long count, WritableByteChannel target)
,把数据从当前通道复制给目标通道
4.2.1 应用实例1 - 本地文件写数据
示例要求:
- 使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道), 将 “hello,尚硅谷” 写入到file01.txt 中。
- 文件不存在就创建。
public class NIOFileChannel {public static void main(String[] args) throws IOException {String str = "hello world";// 创建一个输出流FileOutputStream fileOutputStream = new FileOutputStream("d:\\file01.txt");// 通过fileOutputStream 获取对应的 FileChannel// 注意:是 fileOutputStream 中包裹了 FileChannelFileChannel channel = fileOutputStream.getChannel();// 创建Buffer(缓冲区)ByteBuffer byteBuffer = ByteBuffer.allocate(1024);// 将 str 放入 byteBufferbyteBuffer.put(str.getBytes());// 切换 byteBuffer 为 write 模式byteBuffer.flip();// 将 byteBuffer 中的数据写入到 fileChannelchannel.write(byteBuffer);fileOutputStream.close();}
}
4.2.2 应用实例2 - 本地文件读数据
实例要求:
- 使用 ByteBuffer(缓冲) 和 FileChannel(通道), 将 file01.txt 中的数据读入到程序,并显示在控制台屏幕;
- 假定文件已经存在。
public class NIOFileChannel02 {public static void main(String[] args) throws IOException {String str = "hello world";// 创建一个输入流File file = new File("d:\\file01.txt");FileInputStream fileInputStream = new FileInputStream(file);// 通过fileOutputStream 获取对应的 FileChannelFileChannel channel = fileInputStream.getChannel();// 创建Buffer(缓冲区)ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());// 将 fileChannel 中的数据读入到 byteBufferchannel.read(byteBuffer);// 将 byteBuffer 中的数据转成 StringSystem.out.println(new String(byteBuffer.array()));fileInputStream.close();}
}
4.2.3 应用实例3 - 本地文件的拷贝
实例要求:
- 使用 ByteBuffer(缓冲) 和 FileChannel(通道),完成文件的拷贝
- 拷贝一个文本文件 file01.txt , 放在项目下即可
public class NIOFileChannel03 {public static void main(String[] args) throws IOException {String str = "hello world";// 创建一个输入流File file = new File("d:\\file01.txt");FileInputStream fileInputStream = new FileInputStream(file);// 创建一个输出流FileOutputStream fileOutputStream = new FileOutputStream("d:\\file02.txt");// 通过 fileInputStream 获取对应的 FileChannelFileChannel channel01 = fileInputStream.getChannel();// 通过 fileOutputStream 获取对应的 FileChannelFileChannel channel02 = fileOutputStream.getChannel();// 创建Buffer(缓冲区)ByteBuffer byteBuffer = ByteBuffer.allocate(512);while (true) {// 一次可能读不完,所以清空 byteBufferbyteBuffer.clear();int read = channel01.read(byteBuffer);if (read == -1) {break;}byteBuffer.flip();channel02.write(byteBuffer);}fileInputStream.close();fileOutputStream.close();}
}
4.2.4 应用实例4 - 拷贝文件(transferFrom 方法)
实例要求:
- 使用 FileChannel(通道) 和 方法 transferFrom ,完成文件的拷贝;
- 拷贝一张图片。
public class NIOFileChannel04 {public static void main(String[] args) throws IOException {FileInputStream fileInputStream = new FileInputStream("d:\\a.jpg");FileOutputStream fileOutputStream = new FileOutputStream("d:\\a2.jpg");FileChannel source = fileInputStream.getChannel();FileChannel target = fileOutputStream.getChannel();// 使用 transferForm 完成拷贝target.transferFrom(source,0,source.size());source.close();target.close();fileInputStream.close();fileOutputStream.close();}
}
5 关于Buffer 和 Channel的注意事项和细节
- ByteBuffer 支持类型化的put 和 get, put 放入的是什么数据类型,get就应该使用相应的数据类型来取出,否则可能有 BufferUnderflowException 异常。
- 可以将一个普通Buffer 转成只读Buffer。
- NIO 还提供了
MappedByteBuffer
, 可以让文件直接在内存(堆外的内存
)中进行修改, 而如何同步到文件由NIO 来完成。 - 前面我们讲的读写操作,都是通过一个Buffer 完成的,NIO 还支持
通过多个Buffer (即 Buffer 数组) 完成读写操作
,即Scattering
和Gathering
。
5.1 MappedByteBuffer - 直接在堆外内存中修改文件
MappedByteBuffer
, 可以让文件直接在内存(堆外的内存
)中进行修改,操作系统不需要再拷贝一份,而如何同步到文件由NIO 来完成。
public class NIOMappedByteBuffer {public static void main(String[] args) throws Exception {RandomAccessFile randomAccessFile = new RandomAccessFile("d:\\file01.txt", "rw");FileChannel channel = randomAccessFile.getChannel();/*参数1:FileChannel.MapMode.READ_WRITE,使用的是读写位置参数2:0,可以直接修改的起始位置参数3:5,映射到内存的大小,即将 file01.txt 的多少个字节映射到内存。可以直接修改的范围就是 0 - 5。*/// MappedByteBuffer是一个抽象类,实际类型是 DirectByteBufferMappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);// 将第一个位置的值修改为 HmappedByteBuffer.put(0, (byte) 'H');randomAccessFile.close();}}
5.2 Scattering & Gathering - 多个Buffer(即 Buffer 数组)完成读写操作
- Scattering :将数据写入 Buffer 时,可以采用 Buffer 数组,依次写入【分散】
- Gathering :从 Buffer 读取数据时,可以采用Buffer数组,一次读取
示例:使用 ServerSocketChannel 和 SocketChannel 网络,并使用 Buffer 数组 完成读写操作
public class NIOScatteringGathering {public static void main(String[] args) throws IOException {// 使用 ServerSocketChannel 和 SocketChannel 网络ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);// 绑定端口到 scoket,并启动serverSocketChannel.socket().bind(inetSocketAddress);// 创建Buffer数组ByteBuffer[] byteBuffers = new ByteBuffer[2];byteBuffers[0] = ByteBuffer.allocate(5);byteBuffers[1] = ByteBuffer.allocate(3);// 等待客户端连接SocketChannel socketChannel = serverSocketChannel.accept();// 假定从客户端接收接收 8个字节int messageLen = 8;// 循环读取while (true) {int byteRead = 0;while (byteRead < messageLen) {long r = socketChannel.read(byteBuffers);byteRead += r;// 累计读取的字节数System.out.println("byteRead: "+byteRead);// 使用流打印,看看当前这个buffer的position和limitArrays.asList(byteBuffers).stream().map(buffer -> "position=" + buffer.position() + " , limit=" + buffer.limit()).forEach(System.out::println);}// 将所有的buffer进行反转Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());// 将数据写到通道中long byteWrite = 0;while (byteWrite < messageLen) {long w = socketChannel.write(byteBuffers);byteWrite += w;}// 将所有 buffer 进行 clearArrays.asList(byteBuffers).forEach(buffer -> buffer.clear());System.out.println("byteRead=" + byteRead + " , byteWrite=" + byteWrite);}}
}
6 NIO三大核心组件 之 Selector(选择器)
6.1 Selector(选择器) 基本介绍
- Java 的 NIO,用非阻塞的 IO 方式。可以用一个线程,处理多个的客户端连接,就会使用到
Selector(选择器)
; - Selector 能够检测多个注册的通道上是否有事件发生(注意:多个Channel以事件的方式可以注册到同一个Selector),如果有事件发生,便获取事件然后针对每个事件进行相应的处理。这样就
可以只用一个单线程去管理多个通道,也就是管理多个连接和请求
; - 只有在
连接/通道
真正有读写事件发生时,才会进行读写,就大大地减少了系统开销,并且不必为每个连接都创建一个线程,不用去维护多个线程; - 避免了多线程之间的上下文切换导致的开销。
Selector作用详细说明
- Netty 的 IO 线程 NioEventLoop 聚合了 Selector(选择器,也叫多路复用器),可以同时并发处理成百上千个客户端连接。
- 当线程从某客户端 Socket 通道进行读写数据时,若没有数据可用时,该线程可以进行其他任务。
- 线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作,所以单独的线程可以管理多个输入和输出通道。
- 由于读写操作都是
非阻塞
的,这就可以充分提升 IO线程的运行效率,避免由于频繁 I/O 阻塞导致的线程挂起
。 - 一个 I/O 线程可以并发处理 N 个客户端连接和读写操作,这从根本上解决了传统同步阻塞 I/O 一连接一线程模型,架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。
6.2 Selector类相关方法
Selector 类是一个抽象类, 常用方法和说明如下:
public abstract class Selector implements Closeable {// 得到一个选择器对象public static Selector open();// 监控所有注册的通道,当其中有 IO 操作可以进行时,将对应的 SelectionKey // 加入到内部集合中并返回,参数用来设置超时时间public int select(long timeout);// 从内部集合中得到所有的 SelectionKeypublic Set<SelectionKey> selectedKeys();// 唤醒selectorselector.wakeup();// 不阻塞,立马返还selector.selectNow();
}
- SelectionKey 作用:Selector 对象调用 select() 方法会返回一个 SelectionKey 集合,根据 SelectionKey 获取到对应的channel,然后处理channel中发生的事件。
- select() 或 select(long timeout)
select()
:调用它会一直阻塞,直到获取注册到的Selector中的channel至少有一个channel发生它所关心的事件才返回,返回的是发生事件的channel的SelectionKey。select(long timeout)
:指定阻塞事件,到时见即使没有监听到任何事件也会返回。
6.3 SelectionKey
SelectionKey
表示 Selector
和 网络通道
的 注册关系
, 共四种:
int OP_ACCEPT
:有新的网络连接可以 accept,值为 16;int OP_CONNECT
:代表连接已经建立,值为 8;int OP_READ
:代表读操作,值为 1;int OP_WRITE
:代表写操作,值为 4。
源码中:
public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;
SelectionKey相关方法
public abstract class SelectionKey {public abstract Selector selector();//得到与之关联的 Selector 对象public abstract SelectableChannel channel();//得到与之关联的通道public final Object attachment();//得到与之关联的共享数据public abstract SelectionKey interestOps(int ops);//设置或改变监听事件public final boolean isAcceptable();//是否可以 acceptpublic final boolean isReadable();//是否可以读public final boolean isWritable();//是否可以写
}
6.4 ServerSocketChannel & SocketChannel
ServerSocketChannel 在服务器端监听新的客户端 Socket 连接
public abstract class ServerSocketChannel extends AbstractSelectableChannel implements NetworkChannel{// 得到一个 ServerSocketChannel 通道public static ServerSocketChannel open()// 设置服务器端端口号public final ServerSocketChannel bind(SocketAddress local)// 设置阻塞或非阻塞模式,取值 false 表示采用非阻塞模式public final SelectableChannel configureBlocking(boolean block)// 接受一个连接,返回代表这个连接的通道对象public SocketChannel accept()// 注册一个选择器并设置监听事件public final SelectionKey register(Selector sel, int ops)
}
SocketChannel,网络 IO 通道,具体负责进行读写操作。NIO 把缓冲区的数据写入通道,或者把通道里的数据读到缓冲区。
public abstract class SocketChannelextends AbstractSelectableChannelimplements ByteChannel, ScatteringByteChannel, GatheringByteChannel,NetworkChannel{// 得到一个 SocketChannel 通道public static SocketChannel open();// 设置阻塞或非阻塞模式,取值 false 表示采用非阻塞模式public final SelectableChannel configureBlocking(boolean block);// 连接服务器public boolean connect(SocketAddress remote);// 如果上面的方法连接失败,接下来就要通过该方法完成连接操作public boolean finishConnect();// 往通道里写数据public int write(ByteBuffer src);// 从通道里读数据public int read(ByteBuffer dst);// 注册一个选择器并设置监听事件,最后一个参数可以设置共享数据public final SelectionKey register(Selector sel, int ops, Object att);// 关闭通道public final void close();
}
6.5 Selector、SelectionKey、ServerScoketChannel、SocketChannel关系梳理(重要 重要)
对上图的说明:
- 当客户端连接时,会通过
ServerSocketChannel
(ServerSocketChannel也需要注册到selector上)得到SocketChannel
; - Selector 进行监听 ,通过
select()
方法, 返回有事件发生的通道的个数; - socketChannel调用
register(Selector sel, int ops)
方法,注册到Selector上,一个selector上可以注册多个SocketChannel; - socketChannel注册成功后会返回一个
SelectionKey
,用于和该Selector 关联,多个socketChannel注册成功后就会有一个 SelectionKey 集合; - Selector 通过
select()
方法,返回有事件发生的channel的个数; - 进一步得到各个 SelectionKey (有事件发生的channel的SelectionKey );
- 再通过 SelectionKey 反向获取 SocketChannel (通过
channel()
方法); - 可以通过 得到的 channel,完成业务处理。
register(Selector sel, int ops)中的ops是什么?
public abstract class SelectionKey {public static final int OP_READ = 1 << 0;public static final int OP_WRITE = 1 << 2;public static final int OP_CONNECT = 1 << 3;public static final int OP_ACCEPT = 1 << 4;
}
6.6 应用实例 - NIO 非阻塞 网络编程快速入门
6.6.1 服务器端代码
public class NIOServer {public static void main(String[] args) throws IOException {ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();// 获取 Selector 对象Selector selector = Selector.open();// 绑定端口 6666 在服务端监听serverSocketChannel.socket().bind(new InetSocketAddress(6666));// 设置为非阻塞serverSocketChannel.configureBlocking(false);// 注意:ServerSocketChannel 也需要注册到 Selector 上// 因为客户端总得需要一个通道来通知Server,然后Server再分配一个和cient的单独通道serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);// 循环等待客户端连接while (true) {// 等待1秒,如果没有事件发生,返回if (selector.select(1000) == 0) {System.out.println("服务器等待了1秒,客户端无连接");continue;}// 获取发生关注事件的channel的SelectionKey集合Set<SelectionKey> selectionKeys = selector.selectedKeys();Iterator<SelectionKey> keyIterator = selectionKeys.iterator();while (keyIterator.hasNext()) {// 获取 SelectionKeySelectionKey key = keyIterator.next();// 根据 SelectionKey 对应的 channel 发生的事件做相应的处理if (key.isAcceptable()) { // 如果是 OP_ACCEPT,代表有新的客户端连接Server// 分配一个 SocketChannel 给客户端SocketChannel socketChannel = serverSocketChannel.accept();System.out.println("客户端连接成功,生成了一个socketChannel "+socketChannel.hashCode());// 将 socketChannel 设置为 非阻塞socketChannel.configureBlocking(false);// 将这个 SocketChannel 注册到 selector,关注事件为 OP_READ,// 同时关联一个BuffersocketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));}if (key.isReadable()) {// 发生 事件为 OP_READ// 通过 key 反向获取到 channelSocketChannel socketChannel = (SocketChannel) key.channel();// 获取到该channel关联的bufferByteBuffer buffer = (ByteBuffer) key.attachment();// 将 channel 中的数据读入到 Buffer 中socketChannel.read(buffer);System.out.println("客户端的数据:"+new String(buffer.array()));}// 手动从集合中移除当前的 selectionKey,防止重复操作keyIterator.remove();}}}
}
6.6.2 客户端代码
public class NIOClient {public static void main(String[] args) throws IOException {// 得到一个网络通道SocketChannel socketChannel = SocketChannel.open();// 设置非阻塞模式socketChannel.configureBlocking(false);// 提供服务器端的 ip 和 portInetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);// 连接服务器,非阻塞式连接if (!socketChannel.connect(inetSocketAddress)) {while (!socketChannel.finishConnect()) {System.out.println("因为连接需要时间,客户端不会阻塞,可以做其它工作");}}// 如果连接成功就发送数据String str = "hello world";// 根据字节数的大小,自动设置buffer的大小ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());// 发送数据,将buffer中的数据写入到channelsocketChannel.write(byteBuffer);System.in.read();}
}
Java NIO 编程:Buffer、Channel、Selector原理详解相关推荐
- Java多线程编程中Future模式的详解
转载自 https://www.cnblogs.com/winkey4986/p/6203225.html Java多线程编程中,常用的多线程设计模式包括:Future模式.Master-Worker ...
- JAVA消息服务JMS规范及原理详解
一.简介 JMS即Java消息服务(Java Message Service)应用程序接口,是一个Java平台中关于面向消息中间件(MOM)的API,用于在两个应用程序之间,或分布式系统中发送消息,进 ...
- Java NIO学习篇之缓冲区ByteBuffer详解
定义: ByteBuffer是Buffer的实现类之一,是一个通用的缓冲区,功能要比其他缓冲区子类多.支持直接内存.是一个抽象类.子类实现是HeapByteBuffer(非直接缓冲区子类),Direc ...
- Java NIO学习篇之缓冲区CharSet详解
定义: CharSet是对java nio编码解码的解决方案,专门负责字符的编码和解码. 编码:字符数组.字符串 ===> 字节数组. 解码:字节数组 ==> 字符数组.字符串 API详解 ...
- Java NIO学习篇之通道FileChannel详解
定义: FileChannel是Java NIO对应于磁盘等存储设备文件操作的通道. 常用API详解: 获取FileChannel的API /** * 打开一个与文件的连接通道,用于进行文件操作. * ...
- 【你好面试官】008 Java内存模型指volatile底层原理详解、多处理器原子操作实现原理
微信公众号:你好面试官 这里没有碎片化的知识,只有完整的知识体系. 专注于系统全面的知识点讲解,面试题目解析; 如果你觉得文章对你有帮助,欢迎关注.分享.赞赏. ###前言 二蛋几天没有收到面试通知, ...
- Java网络编程之实现资源下载详解【王道Java】
文章目录 一,前言 二,实现资源下载 三,资源下载的客户端 四,资源下载的服务器端 五,附源码: 5.1,资源下载的客户端 5,2 ,资源下载的服务器端 六,最后 一,前言 有一个作业需求,如下: 实 ...
- java byte转int 互相转换原理详解
转自:https://blog.csdn.net/wojiuai2093/article/details/50779879 int i = 0; i += ((b[0] & 0xff) & ...
- Java并发编程(一)Thread详解
一.概述 在开始学习Thread之前,我们先来了解一下 线程和进程之间的关系: 线程(Thread)是进程的一个实体,是CPU调度和分派的基本单位. 线程不能够独立执行,必须依存在应用程序中,由应用程 ...
最新文章
- SAP S4HANA 使用BP创建供应商报错 - You cannot create a vendor with grouping G001 - 对策
- 蓝牙a2dp硬件卸载是什么意思_索尼这项音频黑科技 让蓝牙音质从此不输有线
- JAVA国际化输出日期格式
- Spring5参考指南:组件扫描
- ASP.NET Core官方文档+源码,这样学效率高10倍!
- selenium禁止弹窗_python:使用带有selenium的firefox时禁用下载弹出窗口
- PWM调光方法在LED亮度调节中的应用
- origin坐标轴在隐藏后如何显示
- mysql 5.7 创建用户_MySQL 5.7 创建用户并授权
- faster rcnn源码阅读笔记2
- WebRTC sdp详解
- 方舟基础物品指令代码大全
- python人民币转大写_python实现人民币大写转换
- 怎么让照片里的人嘴巴动起来_动嘴app最新版(让照片说话的软件)|动嘴app安卓版下载v1.0.0-乐游网安卓下载...
- 在VS2017中添加WTL窗口
- 多节点什么网络取得技术性突破_我国学者研究“多节点量子网络”取得基础性突破...
- Windows 修改hosts过滤小游戏
- 浅谈毕业院校对程序员的影响--蝴蝶如何飞的过沧海?
- 基于python 的股票行情查询系统开发(一)
- 网络媒体教程:采访与写作