1、BIO (Blocking IO)
同步阻塞IO,在 java.io 包下,也就是传统的io,平时就是使用的就是这个。
2、NIO (New IO或者Non-blocking IO)
同步非阻塞IO,在 java.nio 包下,NIO中的N可以理解为Non-blocking,所以nio也叫Non-blocking IO。
3、AIO (Asynchronous IO或者NIO2 )
异步非阻塞IO, AIO 也就是 NIO 2,是NIO 的改进版 NIO 2。
异步 IO 是基于事件和回调机制实现的,也就是应用操作之后会直接返回,不会堵塞在那里,当后台处理完成,操作系统会通知相应的线程进行后续的操作。
4、同步阻塞、同步非阻塞和异步非阻塞又代表什么意思呢?
举个生活中简单的例子,你妈妈让你烧水,小时候你比较笨啊,在哪里傻等着水开(同步阻塞)。
等你稍微再长大一点,你知道每次烧水的空隙可以去干点其他事,然后只需要时不时来看看水开了没有(同步非阻塞)。
后来,你们家用上了水开了会发出声音的壶,这样你就只需要听到响声后就知道水开了,在这期间你可以随便干自己的事情,你需要去倒水了(异步非阻塞)。
NIO 和 BIO 的比较
- BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多
- BIO 是阻塞的,NIO 则是非阻塞的。,
- BIO 基于字节流和字符流进行操作,而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道
NIO | BIO |
---|---|
面向缓冲区(Buffer) | 面向流(Stream) |
非阻塞(Non Blocking IO) | 阻塞IO(Blocking IO) |
选择器(Selectors) |
NIO 基本介绍
- NIO与原来的IO有同样的作用和目的,但是使用的方式完全不同,NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传统的IO的read和write只能阻塞执行,线程在读写IO期间不能干其他事情,比如调用socket.read()时,如果服务器一直没有数据传输过来,线程就一直阻塞,而NIO中可以配置socket为非阻塞模式。
- NIO 有三大核心部分:Channel( 通道) ,Buffer( 缓冲区), Selector( 选择器)
- Java NIO 的非阻塞模式,使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。
- 通俗理解:NIO 是可以做到用一个线程来处理多个操作的。假设有 1000 个请求过来,根据实际情况,可以分配20 或者 80个线程来处理。不像之前的阻塞 IO 那样,非得分配 1000 个。
NIO 三大核心原理示意图
NIO 有三大核心部分:Channel( 通道) ,Buffer( 缓冲区), Selector( 选择器)
Buffer缓冲区
缓冲区本质上是一块可以写入数据,然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象,并提供了一组方法,用来方便的访问该块内存。相比较直接对数组的操作,Buffer API更加容易操作和管理。
Channel(通道)
Java NIO的通道类似流,但又有些不同:既可以从通道中读取数据,又可以写数据到通道。但流的(input或output)读写通常是单向的。 通道可以非阻塞读取和写入通道,通道可以支持读取或写入缓冲区,也支持异步地读写。
Selector选择器
Selector是 一个Java NIO组件,可以能够检查一个或多个 NIO 通道,并确定哪些通道已经准备好进行读取或写入。这样,一个单独的线程可以管理多个channel,从而管理多个网络连接,提高效率
- 每个 channel 都会对应一个 Buffer
- 一个线程对应Selector , 一个Selector对应多个 channel(连接)
- 程序切换到哪个 channel 是由事件决定的
- Selector 会根据不同的事件,在各个通道上切换
- Buffer 就是一个内存块 , 底层是一个数组
- 数据的读取写入是通过 Buffer完成的 , BIO 中要么是输入流,或者是输出流, 不能双向,但是 NIO 的 Buffer 是可以读也可以写。
- Java NIO系统的核心在于:通道(Channel)和缓冲区 (Buffer)。通道表示打开到 IO 设备(例如:文件、 套接字)的连接。若需要使用 NIO 系统,需要获取 用于连接 IO 设备的通道以及用于容纳数据的缓冲 区。然后操作缓冲区,对数据进行处理。简而言之,Channel 负责传输, Buffer 负责存取数据
NIO核心一:缓冲区(Buffer)
缓冲区(Buffer)
一个用于特定基本数据类 型的容器。由 java.nio 包定义的,所有缓冲区 都是 Buffer 抽象类的子类.。Java NIO 中的 Buffer 主要用于与 NIO 通道进行 交互,数据是从通道读入缓冲区,从缓冲区写入通道中的
Buffer 类及其子类
Buffer 就像一个数组,可以保存多个相同类型的数据。根 据数据类型不同 ,有以下 Buffer 常用子类:
- ByteBuffer
- CharBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
上述 Buffer 类 他们都采用相似的方法进行管理数据,只是各自 管理的数据类型不同而已。都是通过如下方法获取一个 Buffer 对象:
static XxxBuffer allocate(int capacity) // 创建一个容量为capacity 的 XxxBuffer 对象
缓冲区的基本属性
Buffer 中的重要概念:
-
容量 (capacity) :作为一个内存块,Buffer具有一定的固定大小,也称为"容量",缓冲区容量不能为负,并且创建后不能更改。
-
限制 (limit):表示缓冲区中可以操作数据的大小(limit 后数据不能进行读写)。缓冲区的限制不能为负,并且不能大于其容量。
写入模式,限制等于buffer的容量。读取模式下,limit等于写入的数据量。 -
位置 (position):下一个要读取或写入的数据的索引。缓冲区的位置不能为负,并且不能大于其限制
-
标记 (mark)与重置 (reset):标记是一个索引,通过 Buffer 中的 mark() 方法 指定 Buffer 中一个特定的 position,之后可以通过调用 reset() 方法恢复到这个 position.
标记、位置、限制、容量遵守以下不变式: 0 <= mark <= position <= limit <= capacity -
图示:
-
-
-
Buffer常见方法
Buffer clear() 清空缓冲区并返回对缓冲区的引用
Buffer flip() 将缓冲区的界限limit设置为当前位置,并将当前位置position设置为0
int capacity() 返回 Buffer 的 capacity 大小
boolean hasRemaining() 判断缓冲区中是否还有元素
int limit() 返回 Buffer 的界限(limit) 的位置
Buffer limit(int n) 将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
Buffer mark() 对缓冲区设置标记
int position() 返回缓冲区的当前位置 position
Buffer position(int n) 将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象
int remaining() 返回 position 和 limit 之间的元素个数
Buffer reset() 将位置 position 转到以前设置的 mark 所在的位置
Buffer rewind() 将位置设为为 0, 取消设置的 mark
缓冲区的数据操作
Buffer 所有子类提供了两个用于数据操作的方法:get()put() 方法
取获取 Buffer中的数据
get() :读取单个字节
get(byte[] dst):批量读取多个字节到 dst 中
get(int index):读取指定索引位置的字节(不会移动 position)
放到 入数据到 Buffer 中 中
put(byte b):将给定单个字节写入缓冲区的当前位置
put(byte[] src):将 src 中的字节写入缓冲区的当前位置
put(int index, byte b):将指定字节写入缓冲区的索引位置(不会移动 position)
使用Buffer读写数据一般遵循以下四个步骤:
- 1.写入数据到Buffer
- 2.调用flip()方法,转换读取模式
- 3.从Buffer中读取数据
- 4.调用buffer.clear()方法或者buffer.compact()方法清除缓冲区
案例演示 debug观察Buffer中pos、lim、cap的变化情况
package com.study.test;
import org.junit.Test;
import java.nio.ByteBuffer;
public class TestBuffer {
@Test
public void test3() {
//分配直接缓冲区
ByteBuffer buf = ByteBuffer.allocateDirect(1024);
System.out.println(buf.isDirect());
}
@Test
public void test2() {
String str = "itheima";
//创建一个容量为 1024 的 Buffer 对象
ByteBuffer buf = ByteBuffer.allocate(1024);//java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]
buf.put(str.getBytes());//java.nio.HeapByteBuffer[pos=7 lim=1024 cap=1024]
//调用 buffer.flip() 反转读写模式
buf.flip();//java.nio.HeapByteBuffer[pos=0 lim=7 cap=1024]
byte[] dst = new byte[buf.limit()];//数组长度为7
buf.get(dst, 0, 2);//pos从0变为2,java.nio.HeapByteBuffer[pos=2 lim=7 cap=1024]
System.out.println(new String(dst, 0, 2));//输出:it
System.out.println(buf.position());//输出:2
//mark() : 标记
buf.mark();//标记记住当前的pos位置,java.nio.HeapByteBuffer[pos=2 lim=7 cap=1024]
buf.get(dst, 2, 2);//java.nio.HeapByteBuffer[pos=4 lim=7 cap=1024]
System.out.println(new String(dst, 2, 2));//输出:he
System.out.println(buf.position());//输出:4
//reset() : 恢复到 mark 的位置
buf.reset();//pos恢复到mark标记的位置,java.nio.HeapByteBuffer[pos=2 lim=7 cap=1024]
System.out.println(buf.position());//输出:2
//判断缓冲区中是否还有剩余数据
if (buf.hasRemaining()) {
//获取缓冲区中可以操作的数量
System.out.println(buf.remaining());//输出:5 = lim - pos
}
}
@Test
public void test1() {
String str = "itheima";
//1. 分配一个指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);//java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]
System.out.println("-----------------allocate()----------------");
System.out.println(buf.position());//输出:0
System.out.println(buf.limit());//输出:1024
System.out.println(buf.capacity());//输出:1024
//2. 利用 put() 存入数据到缓冲区中
buf.put(str.getBytes());//java.nio.HeapByteBuffer[pos=7 lim=1024 cap=1024]
System.out.println("-----------------put()----------------");
System.out.println(buf.position());//输出:7
System.out.println(buf.limit());//输出:1024
System.out.println(buf.capacity());//输出:1024
//3. 切换读取数据模式
buf.flip();//java.nio.HeapByteBuffer[pos=0 lim=7 cap=1024]
System.out.println("-----------------flip()----------------");
System.out.println(buf.position());//输出:0
System.out.println(buf.limit());//输出:7
System.out.println(buf.capacity());//输出:1024
//4. 利用 get() 读取缓冲区中的数据
byte[] dst = new byte[buf.limit()];//数组长度为7
buf.get(dst);//pos从0变为7,java.nio.HeapByteBuffer[pos=7 lim=7 cap=1024]
System.out.println(new String(dst, 0, dst.length));//输出:itheima
System.out.println("-----------------get()----------------");
System.out.println(buf.position());//输出:7
System.out.println(buf.limit());//输出:7
System.out.println(buf.capacity());//输出:1024
//5. rewind() : 可重复读
buf.rewind();//pos从7变为0,java.nio.HeapByteBuffer[pos=0 lim=7 cap=1024]
System.out.println("-----------------rewind()----------------");
System.out.println(buf.position());//输出:0
System.out.println(buf.limit());//输出:7
System.out.println(buf.capacity());//输出:1024
//6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在,但是处于“被遗忘”状态
buf.clear();//并没有清空buf中的数据,lim从0变为cap容量长度1024, java.nio.HeapByteBuffer[pos=0 lim=1024 cap=1024]
System.out.println("-----------------clear()----------------");
System.out.println(buf.position());//输出:0
System.out.println(buf.limit());//输出:1024
System.out.println(buf.capacity());//输出:1024
//get()读取一个字节
System.out.println((char) buf.get()); //输出:i 。pos从0变为7,java.nio.HeapByteBuffer[pos=1 lim=1024 cap=1024]
}
}
直接与非直接缓冲区
什么是直接内存与非直接内存
根据官方文档的描述:
byte byffer
可以是两种类型,一种是基于直接内存(也就是非堆内存);另一种是非直接内存(也就是堆内存)。对于直接内存来说,JVM将会在IO操作上具有更高的性能,因为它直接作用于本地系统的IO操作。而非直接内存,也就是堆内存中的数据,如果要作IO操作,会先从本进程内存复制到直接内存,再利用本地IO处理。
从数据流的角度,非直接内存是下面这样的作用链:
本地IO-->直接内存-->非直接内存-->直接内存-->本地IO
而直接内存是:
本地IO-->直接内存-->本地IO
很明显,在做IO处理时,比如网络发送大量数据时,直接内存会具有更高的效率。直接内存使用allocateDirect创建,但是它比申请普通的堆内存需要耗费更高的性能。不过,这部分的数据是在JVM之外的,因此它不会占用应用的内存。所以呢,当你有很大的数据要缓存,并且它的生命周期又很长,那么就比较适合使用直接内存。只是一般来说,如果不是能带来很明显的性能提升,还是推荐直接使用堆内存。字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。
使用场景
- 1 有很大的数据需要存储,它的生命周期又很长
- 2 适合频繁的IO操作,比如网络并发场景
NIO核心二:通道(Channel)
通道Channe概述
通道(Channel):由 java.nio.channels 包定义 的。Channel 表示 IO 源与目标打开的连接。 Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据,Channel 只能与 Buffer 进行交互。
1、 NIO 的通道类似于流,但有些区别如下:
-
通道可以同时进行读写,而流只能读或者只能写
-
通道可以实现异步读写数据
-
通道可以从缓冲读数据,也可以写数据到缓冲:
2、BIO 中的 stream(流) 是单向的,例如 FileInputStream 对象只能进行读取数据的操作,FileOutputStream 对象只能进行写数据的操作,
而 NIO 中的通道(Channel)是双向的,可以读操作,也可以写操作。
3、Channel 在 NIO 中是一个接口
public interface Channel extends Closeable{}
常用的Channel实现类
- FileChannel:用于读取、写入、映射和操作文件的通道。
- DatagramChannel:通过 UDP 读写网络中的数据通道。
- SocketChannel:通过 TCP 读写网络中的数据。
- ServerSocketChannel:可以监听新进来的 TCP 连接,对每一个新进来的连接都会创建一个 SocketChannel。
【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】
FileChannel 类
获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下:
- FileInputStream
- FileOutputStream
- RandomAccessFile
- DatagramSocket
- Socket
- ServerSocket
获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道
FileChannel的常用方法
int read(ByteBuffer dst) 从 Channel 中读取数据到 ByteBuffer
long read(ByteBuffer[] dsts) 将 Channel 中的数据“分散”到 ByteBuffer[]
int write(ByteBuffer src) 将 ByteBuffer 中的数据写入到 Channel
long write(ByteBuffer[] srcs) 将 ByteBuffer[] 中的数据“聚集”到 Channel
long position() 返回此通道的文件位置
FileChannel position(long p) 设置此通道的文件位置
long size() 返回此通道的文件的当前大小
FileChannel truncate(long s) 将此通道的文件截取为给定大小
void force(boolean metaData) 强制将所有对此通道的文件更新写入到存储设备中
案例1-本地文件写数据
需求:使用前面学习后的 ByteBuffer(缓冲) 和 FileChannel(通道), 将 “hello,黑马Java程序员!” 写入到 data.txt 中.
Buffer > Channel > File
package com.study.test;
import org.junit.Test;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ChannelTest {
@Test
public void write() {
try {
// 1、字节输出流通向目标文件
FileOutputStream fos = new FileOutputStream("d:/data01.txt");
// 2、得到字节输出流对应的通道Channel
FileChannel channel = fos.getChannel();
// 3、分配缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("hello,黑马Java程序员!".getBytes());
// 4、把缓冲区切换成写出模式
buffer.flip();
channel.write(buffer);
channel.close();
System.out.println("写数据到文件中!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
案例2-本地文件读数据
需求:使用前面学习后的 ByteBuffer(缓冲) 和 FileChannel(通道), 将 data01.txt 中的数据读入到程序,并显示在控制台屏幕
File > Channel > Buffer
@Test
public void read() throws Exception {
// 1、定义一个文件字节输入流与源文件接通
FileInputStream is = new FileInputStream("d:/data01.txt");
// 2、需要得到文件字节输入流的文件通道
FileChannel channel = is.getChannel();
// 3、定义一个缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 4、读取数据到缓冲区
channel.read(buffer);
buffer.flip();
// 5、读取出缓冲区中的数据并输出即可
//remaining() 返回 position 和 limit 之间的元素个数
String rs = new String(buffer.array(),0,buffer.remaining());
System.out.println(rs);
}
案例3-使用Buffer完成文件复制
使用 FileChannel(通道) ,完成文件的拷贝。
@Test
public void copy() throws Exception {
// 源文件
File srcFile = new File("D:\\壁纸.jpg");
File destFile = new File("D:\\壁纸new.jpg");
// 得到一个字节字节输入流
FileInputStream fis = new FileInputStream(srcFile);
// 得到一个字节输出流
FileOutputStream fos = new FileOutputStream(destFile);
// 得到的是文件通道
FileChannel isChannel = fis.getChannel();
FileChannel osChannel = fos.getChannel();
// 分配缓冲区,初始化后lim和容量cap大小相同。
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
// 必须先清空缓冲然后再写入数据到缓冲区
buffer.clear();//事实上并没有清空buffer中的数据,只是将pos置为0,lim置为cap容量大小
// 开始读取一次数据,返回数据长度
int len = isChannel.read(buffer);//pos大小变为数据长度大小
if (len == -1) {
break;
}
if (len != 1024) {
System.out.println();//断点观察
}
// 已经读取了数据 ,把缓冲区的模式切换成可读模式
buffer.flip();//pos变为0,lim大小变为数据长度大小
// 把数据写出到
osChannel.write(buffer);//pos变为lim大小(即数据长度大小)
}
isChannel.close();
osChannel.close();
System.out.println("复制完成!");
}
案例4-分散 (Scatter) 和聚集 (Gather)
分散读取(Scatter ):是指把Channel通道的数据读入到多个缓冲区中去
聚集写入(Gathering )是指将多个 Buffer 中的数据“聚集”到 Channel。
d:/1.txt文件内容为:123456789
//分散和聚集
@Test
public void test() throws IOException {
RandomAccessFile raf1 = new RandomAccessFile("d:/1.txt", "rw");
//1. 获取通道
FileChannel channel1 = raf1.getChannel();
//2. 分配指定大小的缓冲区
ByteBuffer buf1 = ByteBuffer.allocate(5);
ByteBuffer buf2 = ByteBuffer.allocate(1024);
//3. 分散读取
ByteBuffer[] bufs = {buf1, buf2};
channel1.read(bufs);
for (ByteBuffer byteBuffer : bufs) {
byteBuffer.flip();//pos变为0,lim大小变为数据长度大小
}
System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));//结果:12345
System.out.println("-----------------");
System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));//结果:6789
//4. 聚集写入
RandomAccessFile raf2 = new RandomAccessFile("d:/2.txt", "rw");
FileChannel channel2 = raf2.getChannel();
channel2.write(bufs);
}
案例5-transferFrom()
从目标通道中去复制原通道数据
@Test
public void test02() throws Exception {
// 1、字节输入管道
FileInputStream is = new FileInputStream("d:/data01.txt");
FileChannel isChannel = is.getChannel();
// 2、字节输出流管道
FileOutputStream fos = new FileOutputStream("d:/data03.txt");
FileChannel osChannel = fos.getChannel();
// 3、复制
osChannel.transferFrom(isChannel,isChannel.position(),isChannel.size());
isChannel.close();
osChannel.close();
}
案例6-transferTo()
把原通道数据复制到目标通道
@Test
public void test03() throws Exception {
// 1、字节输入管道
FileInputStream is = new FileInputStream("d:/data01.txt");
FileChannel isChannel = is.getChannel();
// 2、字节输出流管道
FileOutputStream fos = new FileOutputStream("d:/data04.txt");
FileChannel osChannel = fos.getChannel();
// 3、复制
isChannel.transferTo(isChannel.position() , isChannel.size() , osChannel);
isChannel.close();
osChannel.close();
}
NIO核心三:选择器(Selector)
选择器(Selector)概述
选择器(Selector) 是 SelectableChannle 对象的多路复用器,Selector 可以同时监控多个 SelectableChannel 的 IO 状况,也就是说,利用 Selector可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心
- Java 的 NIO,用非阻塞的 IO 方式。可以用一个线程,处理多个的客户端连接,就会使用到 Selector(选择器)
- Selector 能够检测多个注册的通道上是否有事件发生(注意:多个 Channel 以事件的方式可以注册到同一个
Selector),如果有事件发生,便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管
理多个通道,也就是管理多个连接和请求。 - 只有在 连接/通道 真正有读写事件发生时,才会进行读写,就大大地减少了系统开销,并且不必为每个连接都
创建一个线程,不用去维护多个线程 - 避免了多线程之间的上下文切换导致的开销
选择器(Selector)的应用
创建 Selector :通过调用 Selector.open() 方法创建一个 Selector。
Selector selector = Selector.open();
向选择器注册通道:SelectableChannel.register(Selector sel, int ops)
//1. 获取通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
//2. 切换非阻塞模式
ssChannel.configureBlocking(false);
//3. 绑定连接
ssChannel.bind(new InetSocketAddress(9898));
//4. 获取选择器
Selector selector = Selector.open();
//5. 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
当调用 register(Selector sel, int ops) 将通道注册选择器时,选择器对通道的监听事件,需要通过第二个参数 ops 指定。可以监听的事件类型(用 可使用 SelectionKey 的四个常量 表示):
- 读 : SelectionKey.OP_READ (1)
- 写 : SelectionKey.OP_WRITE (4)
- 连接 : SelectionKey.OP_CONNECT (8)
- 接收 : SelectionKey.OP_ACCEPT (16)
- 若注册时不止监听一个事件,则可以使用“位或”操作符连接。
int interestSet = SelectionKey.OP_READ|SelectionKey.OP_WRITE
NIO非阻塞式网络通信原理分析
Selector 示意图和特点说明
Selector可以实现: 一个 I/O 线程可以并发处理 N 个客户端连接和读写操作,这从根本上解决了传统同步阻塞 I/O 一连接一线程模型,架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。
1、当客户端连接服务端时,服务端会通过 ServerSocketChannel 得到 SocketChannel:1. 获取通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
2、切换非阻塞模式
ssChannel.configureBlocking(false);
3、绑定连接,设置服务端监听端口
ssChannel.bind(new InetSocketAddress(9999));
4、 获取选择器
Selector selector = Selector.open();
5、 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
6、 轮询式的获取选择器上已经“准备就绪”的事件
//轮询式的获取选择器上已经“准备就绪”的事件
while (selector.select() > 0) {
System.out.println("轮一轮");
//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
//8. 获取准备“就绪”的是事件
SelectionKey sk = it.next();
//9. 判断具体是什么事件准备就绪
if (sk.isAcceptable()) {
//10. 若“接收就绪”,获取客户端连接
SocketChannel sChannel = ssChannel.accept();
//11. 切换非阻塞模式
sChannel.configureBlocking(false);
//12. 将该通道注册到选择器上
sChannel.register(selector, SelectionKey.OP_READ);
} else if (sk.isReadable()) {
//13. 获取当前选择器上“读就绪”状态的通道
SocketChannel sChannel = (SocketChannel) sk.channel();
//14. 读取数据
ByteBuffer buf = ByteBuffer.allocate(1024);
int len = 0;
while ((len = sChannel.read(buf)) > 0) {
buf.flip();
System.out.println(new String(buf.array(), 0, len));
buf.clear();
}
}
//15. 取消选择键 SelectionKey
it.remove();
}
}
}
客户端流程
1、获取通道
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
2、切换非阻塞模式
sChannel.configureBlocking(false);
3、分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);
4、发送数据给服务端
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
String str = scan.nextLine();
buf.put((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(System.currentTimeMillis())
+ "\n" + str).getBytes());
buf.flip();
sChannel.write(buf);
buf.clear();
}
//关闭通道
sChannel.close();
NIO非阻塞式网络通信入门案例
需求:服务端接收客户端的连接请求,并接收多个客户端发送过来的事件。
代码案例(这个案例没有实现服务端响应客户端)
服务端
package com.study.test;
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;
public class Server {
public static void main(String[] args) throws IOException {
//1. 获取通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
//2. 切换非阻塞模式
ssChannel.configureBlocking(false);
//3. 绑定连接
ssChannel.bind(new InetSocketAddress(9999));
//4. 获取选择器
Selector selector = Selector.open();
//5. 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
//6. 轮询式的获取选择器上已经“准备就绪”的事件
// selector.select() 方法会阻塞,直到有客户端连接进来,或者客户端SocketChannel发送数据过来
while (selector.select() > 0) {
System.out.println("轮一轮");
//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
//8. 获取准备“就绪”的是事件
SelectionKey sk = it.next();
//9. 判断具体是什么事件准备就绪
if (sk.isAcceptable()) {
//10. 若“接收就绪”,获取客户端连接
SocketChannel sChannel = ssChannel.accept();
//11. 切换非阻塞模式
sChannel.configureBlocking(false);
//12. 将该通道注册到选择器上
sChannel.register(selector, SelectionKey.OP_READ);
} else if (sk.isReadable()) {
//13. 获取当前选择器上“读就绪”状态的通道
SocketChannel sChannel = (SocketChannel) sk.channel();
//14. 读取数据
ByteBuffer buf = ByteBuffer.allocate(1024);//[pos=0 lim=1024 cap=1024]
int len;//数据长度
while ((len = sChannel.read(buf)) > 0) {//[pos=数据长度 lim=1024 cap=1024]
buf.flip();//[pos=0 lim=数据长度 cap=1024]
System.out.println(new String(buf.array(), 0, len));
buf.clear();
}
}
//15. 取消选择键 SelectionKey
it.remove();
}
}
}
}
客户端
package com.study.test;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.Scanner;
public class Client {
public static void main(String[] args) throws Exception {
//1. 获取通道
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
//2. 切换非阻塞模式
sChannel.configureBlocking(false);
//3. 分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);
//4. 发送数据给服务端
Scanner scan = new Scanner(System.in);
while (scan.hasNext()) {
String str = scan.nextLine();
buf.put((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(System.currentTimeMillis())
+ "\n" + str).getBytes());
buf.flip();
sChannel.write(buf);
buf.clear();
}
//5. 关闭通道
sChannel.close();
}
}
这个案例启动了一个 Selector 选择器,将服务端通道 ServerSocketChannel 注册到 Selector 选择器上,并绑定一个接收 OP_ACCEPT 事件
然后调用 Selector 选择器select()方法,这个方法是阻塞,直到 有 OP_ACCEPT事件(有客户端SocketChannel 连接请求),select()方法不再阻塞,继续往下执行,
接收到客户端SocketChannel 连接请求后,将这个SocketChannel 再注册到 Selector 选择器上,并绑定一个读 OP_READ 事件,以后 选择器 就可以监听到 客户端发送过来的数据
每次 Selector 选择器 接收到 事件驱动后 要记得移除 这个驱动事件。
整个过程,Selector 选择器,在Channel通道之间 通过Channel通道各种绑定的事件驱动 来回切换。
NIO 网络编程应用实例-群聊系统
目标
需求:进一步理解 NIO 非阻塞网络编程机制,实现多人群聊
- 编写一个 NIO 群聊系统,实现客户端与客户端的通信需求(非阻塞)
- 服务器端:可以监测用户上线,离线,并实现消息转发功能
- 客户端:通过 channel 可以无阻塞发送消息给其它所有客户端用户,同时可以接受其它客户端用户通过服务端转发来的消息
服务端代码实现
package com.study.chat;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
public class Server {
//定义属性
private Selector selector;
private ServerSocketChannel ssChannel;
private static final int PORT = 9999;
//构造器
//初始化工作
public Server() {
try {
// 1、获取通道
ssChannel = ServerSocketChannel.open();
// 2、切换为非阻塞模式
ssChannel.configureBlocking(false);
// 3、绑定连接的端口
ssChannel.bind(new InetSocketAddress(PORT));
// 4、获取选择器Selector
selector = Selector.open();
// 5、将通道都注册到选择器上去,并且开始指定监听接收事件
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//创建服务器对象
Server groupChatServer = new Server();
groupChatServer.listen();
}
//监听
public void listen() {
System.out.println("监听线程: " + Thread.currentThread().getName());
try {
while (selector.select() > 0) {
System.out.println("开始一轮事件处理~~~");
// 7、获取选择器中的所有注册的通道中已经就绪好的事件
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
// 8、开始遍历这些准备好的事件
while (it.hasNext()) {
// 提取当前这个事件
SelectionKey sk = it.next();
// 9、判断这个事件具体是什么
if (sk.isAcceptable()) {
// 10、直接获取当前接入的客户端通道
SocketChannel schannel = ssChannel.accept();
// 11 、切换成非阻塞模式
schannel.configureBlocking(false);
// 12、将本客户端通道注册到选择器
System.out.println(schannel.getRemoteAddress() + " 上线 ");
schannel.register(selector, SelectionKey.OP_READ);
//提示
} else if (sk.isReadable()) {
//处理读 (专门写方法..)
readData(sk);
}
it.remove(); // 处理完毕之后需要移除当前事件
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
}
}
//读取客户端消息
private void readData(SelectionKey key) {
//取到关联的channle
SocketChannel channel = null;
try {
//得到channel
channel = (SocketChannel) key.channel();
// 与对方约定前3个字节为消息内容长度
// 3个字节(1个字节8位二进制):表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。
// 首先取出前3个字节,计算消息内容的长度
ByteBuffer headBuf = ByteBuffer.allocate(3);
channel.read(headBuf);
headBuf.flip();//pos变为0,lim大小变为数据长度大小
// 约定前3个字节为消息内容长度
byte first = headBuf.get();
byte second = headBuf.get();
byte third = headBuf.get();
// 消息内容长度
int length = (first << 16) + (second << 8) + third;
//创建buffer
ByteBuffer buf = ByteBuffer.allocate(1024);//[pos=0 lim=1024 cap=1024]
int len;//数据长度
StringBuilder msg = new StringBuilder();
for (int i = 0; i < length; i += len) {
buf.clear();//事实上并没有清空buffer中的数据,只是将pos置为0,lim置为cap容量大小 [pos=0 lim=1024 cap=1024]
// 开始读取一次数据,返回数据长度
len = channel.read(buf);//pos变为数据长度大小 [pos=数据长度 lim=1024 cap=1024]
if (len == -1) {
break;
}
if (len == 0) {
Thread.sleep(100);
} else {
buf.flip();//pos变为0,lim大小变为数据长度大小 [pos=0 lim=数据长度 cap=1024]
// 从buffer中取出数据
msg.append(new String(buf.array(), 0, len));
}
}
//输出该消息
System.out.println("form 客户端: " + msg);
// 到这里就可以将接收到的消息内容放入 MQ 或者开启一个子线程来处理消息内容了。
//向其它的客户端转发消息(去掉自己), 专门写一个方法来处理
sendInfoToOtherClients(msg.toString(), channel);
} catch (Exception e) {
try {
System.out.println(channel.getRemoteAddress() + " 离线了..");
e.printStackTrace();
//取消注册
key.cancel();
//关闭通道
channel.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
//转发消息给其它客户(通道)
private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
System.out.println("服务器转发消息中...");
System.out.println("服务器转发数据给客户端线程: " + Thread.currentThread().getName());
//遍历 所有注册到selector 上的 SocketChannel,并排除 self
for (SelectionKey key : selector.keys()) {
try {
//通过 key 取出对应的 SocketChannel
Channel targetChannel = key.channel();
//排除自己
if (targetChannel instanceof SocketChannel && targetChannel != self) {
//转型
SocketChannel dest = (SocketChannel) targetChannel;
//将msg 存储到buffer
ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
// 首先需要计算消息内容的长度
int length = buffer.limit();
// 与对方约定前3个字节为消息内容长度
// 3个字节(1个字节8位二进制):表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。
ByteBuffer headBuf = ByteBuffer.allocate(3);
// int是4个字节32位,byte是1个字节8位,int类型转化为byte类型时会出现位丢失情况,即将int的低8位作为byte类型的值,高8位丢弃。
headBuf.put((byte) (length >> 16));
headBuf.put((byte) (length >> 8));
headBuf.put((byte) length);
headBuf.flip();//pos变为0,lim大小变为数据长度大小
// 将消息的长度优先发送出去,消息长度约定占3个字节
dest.write(headBuf);
// Thread.sleep(10000);//模拟粘包拆包
// 发送消息内容
dest.write(buffer);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
客户端代码实现
package com.study.chat;
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.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
public class Client {
//定义相关的属性
private final String HOST = "127.0.0.1"; // 服务端的ip
private final int PORT = 9999; //服务端的端口
private Selector selector;
private SocketChannel socketChannel;
private String username;
//构造器, 完成初始化工作
public Client() throws IOException {
selector = Selector.open();
//连接服务器
socketChannel = socketChannel.open(new InetSocketAddress(HOST, PORT));
//设置非阻塞
socketChannel.configureBlocking(false);
//将channel 注册到selector
socketChannel.register(selector, SelectionKey.OP_READ);
//得到username
username = socketChannel.getLocalAddress().toString().substring(1);
System.out.println(username + " is ok...");
}
public static void main(String[] args) throws Exception {
//启动我们客户端
Client chatClient = new Client();
// Selector选择器,会阻塞线程,需要单独开一个子线程来完成
new Thread() {
public void run() {
chatClient.readInfo();
}
}.start();
//从控制台接收数据,发送数据给服务器端
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
String s = scanner.nextLine();
chatClient.sendInfo(s);
}
}
//向服务器发送消息
public void sendInfo(String info) {
info = username + " 说:" + info;
try {
ByteBuffer buffer = ByteBuffer.wrap(info.getBytes());
// 首先需要计算消息内容的长度
int length = buffer.limit();
// 与对方约定前3个字节为消息内容长度
// 3个字节(1个字节8位二进制):表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。
ByteBuffer headBuf = ByteBuffer.allocate(3);
// int是4个字节32位,byte是1个字节8位,int类型转化为byte类型时会出现位丢失情况,即将int的低8位作为byte类型的值,高8位丢弃。
headBuf.put((byte) (length >> 16));
headBuf.put((byte) (length >> 8));
headBuf.put((byte) length);
headBuf.flip();//pos变为0,lim大小变为数据长度大小
// 将消息的长度优先发送出去,消息长度约定占3个字节
socketChannel.write(headBuf);
Thread.sleep(10000);//模拟粘包拆包
// 发送消息内容
socketChannel.write(buffer);
} catch (Exception e) {
e.printStackTrace();
}
}
//读取从服务器端回复的消息
public void readInfo() {
try {
while (selector.select() > 0) {//有可以用的通道
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
if (key.isReadable()) {
//处理读 (专门写方法..)
readData(key);
}
}
iterator.remove(); //删除当前的selectionKey, 防止重复操作
}
} catch (Exception e) {
e.printStackTrace();
}
}
//读取客户端消息
private void readData(SelectionKey key) {
//取到关联的channle
SocketChannel channel = null;
try {
//得到channel
channel = (SocketChannel) key.channel();
// 与对方约定前3个字节为消息内容长度
// 3个字节(1个字节8位二进制):表示一条消息内容最大长度 2^24-1 = 16777215K ≈ 16M。如果约定4个字节一条消息内容最大长度为4G。
// 首先取出前3个字节,计算消息内容的长度
ByteBuffer headBuf = ByteBuffer.allocate(3);
channel.read(headBuf);
headBuf.flip();//pos变为0,lim大小变为数据长度大小
// 约定前3个字节为消息内容长度
byte first = headBuf.get();
byte second = headBuf.get();
byte third = headBuf.get();
// 消息内容长度
int length = (first << 16) + (second << 8) + third;
//创建buffer
ByteBuffer buf = ByteBuffer.allocate(1024);//[pos=0 lim=1024 cap=1024]
int len;//数据长度
StringBuilder msg = new StringBuilder();
for (int i = 0; i < length; i += len) {
buf.clear();//事实上并没有清空buffer中的数据,只是将pos置为0,lim置为cap容量大小 [pos=0 lim=1024 cap=1024]
// 开始读取一次数据,返回数据长度
len = channel.read(buf);//pos变为数据长度大小 [pos=数据长度 lim=1024 cap=1024]
if (len == -1) {
break;
}
if (len == 0) {
Thread.sleep(100);
} else {
buf.flip();//pos变为0,lim大小变为数据长度大小 [pos=0 lim=数据长度 cap=1024]
// 从buffer中取出数据
msg.append(new String(buf.array(), 0, len));
}
}
//输出该消息
System.out.println(msg);
// 到这里就可以将接收到的消息内容放入 MQ 或者开启一个子线程来处理消息内容了。
} catch (Exception e) {
try {
System.out.println(channel.getRemoteAddress() + " 离线了..");
e.printStackTrace();
//取消注册
key.cancel();
//关闭通道
channel.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
可以参考我另一篇传统的socket的处理方式:Java网络编程Socket_java中socket的用法_小百菜的博客-CSDN博客
上面的服务端和客户端方法 readData() 被我改造成阻塞式的了, readData()方法里面的 for 循环是一个阻塞方法如果 len为0 会一直循环导致整个方法阻塞。这样有违背nio的初衷。
这样做跟传统的socket没有区别了,传统的io的read方法会阻塞,而nio的Buffer缓冲区read方法不会阻塞,nio的read方法会立即返回 然后去做其他事,而不是像我这样一直在for循环中等待,这样跟阻塞没什么区别,由于时间有限,先搁置后面有空再完善。
初步改善逻辑是,首先知道有很多 SocketChannel 通道,选择器Selector在这些通道之间来回切换,
设置一个全局变量,以SocketChannel 为key,值为当前SocketChannel 中已经取到的消息内容,消息长度,剩余消息长度等进度。
每次切换到某一个SocketChannel 通道时,先从全局变量取出上次的进度,继续取数,取数完毕就从全局变量中去除当前SocketChannel 的key。
JAVA AIO深入剖析
AIO编程
- Java AIO(NIO.2) : 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。
BIO NIO AIO
Socket SocketChannel AsynchronousSocketChannel
ServerSocket ServerSocketChannel AsynchronousServerSocketChannel
与NIO不同,当进行读写操作时,只须直接调用API的read或write方法即可, 这两种方法均为异步的,对于读操作而言,当有流可读取时,操作系统会将可读的流传入read方法的缓冲区,对于写操作而言,当操作系统将write方法传递的流写入完毕时,操作系统主动通知应用程序
即可以理解为,read/write方法都是异步的,完成后会主动调用回调函数。在JDK1.7中,这部分内容被称作NIO.2,主要在Java.nio.channels包下增加了下面四个异步通道:
AsynchronousSocketChannel
AsynchronousServerSocketChannel
AsynchronousFileChannel
AsynchronousDatagramChannel
BIO,NIO,AIO课程总结
BIO、NIO、AIO:
- Java BIO : 同步并阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。
- Java NIO : 同步非阻塞,服务器实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
- Java AIO(NIO.2) : 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。
BIO、NIO、AIO适用场景分析:
- BIO方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4以前的唯一选择,但程序直观简单易理解。
- NIO方式适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,并发局限于应用中,编程比较复杂,JDK1.4开始支持。Netty!
- AIO方式使用于连接数目多且连接比较长(重操作)的架构,比如相册服务器,充分调用OS参与并发操作,编程比较复杂,JDK7开始支持。
参考: