java基础之NIO介绍及使用-APISpace

java基础之NIO介绍及使用

一、NIO

java.nio全称java non-blocking IO，是指jdk1.4 及以上版本里提供的新api（New IO），为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。

二、三大组件

NIO三大组件：Channel、Buffer、Selector

1.Channel 和Buffer

Channel是一个对象，可以通过它读取和写入数据。拿 NIO 与原来的 I/O 做个比较，通道就像是流，而且他们面向缓冲区（Buffer）的。所有数据都通过Buffer对象来处理，永远不会将字节直接写入通道中，而是将数据写入包含一个或多个字节的缓冲区。也不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

Channel是读写数据的双向通道，可以从Channel将数据读取Buffer,也可将Buffer的数据写入Channel，而之前的Stream要么是输入（InputStream）、要么是输出（OutputStream），只在一个方向上流通。而通道（Channel）可以用于读、写或者同时用于读写

常见的Channel

1.FileChannel

2.DatagramChannel

3.SocketChannel

4.ServerSocketChannel

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

1.ByteBuffer

2.ShortBuffer

3.IntBuffer

4.LongBuffer

5.FloatBuffer

6.DoubleBuffer

7.CharBuffer

2.Selector

在多线程模式下，阻塞IO时，一个线程只能处理一个请求，比如http请求，当请求响应式关闭连接，释放线程资源。Selector选择器的作用就是配合一个线程来管理多个Channel，获取这些Channel上发生的事件，这些Channel工作在非阻塞模式下，不会让线程一直在一个Channel上，适合连接数特别多，但流量低的场景。

调用Selector的select()方法会阻塞直到Channel发送了读写就绪事件，这些事件发生，select()方法就会

返回这些事件交给thread来处理。

三、ByteBuffer的使用

属性：

Buffer的读写操作就是通过改变position，mark，limit的值来实现。注意他们之间的关系可以很轻松的读、写、覆盖。

position：对于写入模式，表示当前可写入数据的下标，对于读取模式，表示接下来可以读取的数据的下标。当前操作位置的下标。position()方法获取。

mark：用来标志当前操作位置，调用mark()方法，使mark = position，可以在读和写切换过程中标记前一个操作下标位置。

limit：Buffer的限界值。对于写模式，相当于可写入的最大值，数组长度。对于读模式，表示最多可以读取的数据的位置下标，通过flip()方法进行读写切换，原理改变position，mark，limit的值。

capacity：数组容量大小

方法：

Buffer的方法全是根据改变position的值进行操作的。

put()：put方法写入数据，可以单个byte字节，或者byte数组。或者其它类型，根据Buffer实例而定。

get()：get方法读取数据，可以传入byte数组和不传参读取一个字节。

mark()：标记当前下标position位置，mark = position 。读写操作切换或者特殊要求时，标记当前的下标位置。

reset()：将position 值重置为mark()方法标记的值。

array()：Buffer内数据的byte数组。没有值的位用0补位。

flip()：limit为position值，将position置为0，mark初始值，写入操作切换为读操作。

rewind()：将position 和 mark设为初始值，调用这个可以一直读取内容或者一直写入覆盖之前内容，从第一位开始读/写。

clear()：将属性值还原。之前array()数组的值还在。

hasRemaining()：判断是否到最后

四、测试Demo

private static void buffer1() {

String data = "abc";

//byte[] bytes = new byte[1024];

//创建一个字节缓冲区，1024byte

ByteBuffer byteBuffer = ByteBuffer.allocate(15);

System.out.println(byteBuffer.toString());

// 标记当前下标position位置，mark = position ,返回当前对象

System.out.println(byteBuffer.mark());

//对于写入模式，表示当前可以写入的数组大小，默认为数组的最大长度，对于读取模式，表示当前最多可以读取的数据的位置下标

System.out.println(byteBuffer.limit());

// 对于写入模式，表示当前可写入数据的下标，对于读取模式，表示接下来可以读取的数据的下标

System.out.println(byteBuffer.position());

//capacity 表示当前数组的容量大小

System.out.println(byteBuffer.capacity());

//将字节数据写入 byteBuffer

byteBuffer.put(data.getBytes());

//保存了当前写入的数据

for(Byte b : byteBuffer.array()){

System.out.print(b + " ");

}

System.out.println();

System.out.println(new String(byteBuffer.array()));

//读写模式切换改变 limit，position ，mark的值

byteBuffer.flip();

//切换为写模式，将第一个字节覆盖

byteBuffer.put("n".getBytes()); // abc 改为 nbc

System.out.println(new String(byteBuffer.array()));

//让position为之前标记的值，调用mark()方法是将mark = position，这里将position = mark，mark为初始值抛出异常

byteBuffer.mark();

byteBuffer.reset();

//将position 和 mark设为初始值，调用这个可以一直读取内容或者一直写入覆盖之前内容，从第一位开始读/写

byteBuffer.rewind();

for(Byte b : byteBuffer.array()){

System.out.print(b + " ");

}

System.out.println();

System.out.println(byteBuffer.toString());

//找到可写入的开始位置，不覆盖之前的数据

byteBuffer.compact();

System.out.println(byteBuffer.toString());

}

写入读取完整操作

private static void buffer(){

//写入的数据

String data = "1234";

//创建一个字节缓冲区，1024byte

ByteBuffer byteBuffer = ByteBuffer.allocate(15);

//写入数据

byteBuffer.put(data.getBytes());

//打输出 49 50 51 52 0 0 0 0 0 0 0 0 0 0 0

println(byteBuffer.array());

byteBuffer.put((byte) 5);

//追加写入输出： 49 50 51 52 5 0 0 0 0 0 0 0 0 0 0

println(byteBuffer.array());

//覆盖写入

byteBuffer.flip(); //将写入下标的 position = 0

byteBuffer.put((byte) 1);

byteBuffer.put((byte) 2);

byteBuffer.put((byte) 3);

byteBuffer.put((byte) 4);

byteBuffer.put((byte) 5);

// 打印输出： 1 2 3 4 5 0 0 0 0 0 0 0 0 0 0

println(byteBuffer.array());

//读取数据操作

byteBuffer.flip();//从头开始读

while (byteBuffer.position() != byteBuffer.limit()){

System.out.println(byteBuffer.get());

}

//此时 position 和数据数 limit相等

System.out.println(byteBuffer.toString());

//批量读取

byteBuffer.flip(); //将 position 置位0，从头开始操作

//创建一个byte数组，数组大小为可读取的大小

byte[] bytes = new byte[byteBuffer.limit()];

byteBuffer.get(bytes);

//输出bytes 1 2 3 4 5

println(bytes);

}

private static void println(byte[] bytes){

for(Byte b : bytes){

System.out.print(b + " ");

}

System.out.println();

}

字符串跟ByteBuffer之间的转换

public static void main(String[] args) {

/*======================字符串转buffer===========================*/

//1.字符串转为buytebuffer 需要转为读模式再进行读取操作

ByteBuffer buffer = ByteBuffer.allocate(1024);

buffer.put("nio".getBytes());

//2.charset 自动转为读模式

ByteBuffer buffer1 = StandardCharsets.UTF_8.encode("nio");

//3, warp 自动转为读模式

ByteBuffer buffer2 = ByteBuffer.wrap("nio".getBytes());

/*======================buffer转字符串===========================*/

String str = StandardCharsets.UTF_8.decode(buffer1).toString();

System.out.println(str);

}

五、Channel的使用

文件编程FileChannel

FileChannel只能工作在阻塞模式下，不能配合在Selector使用，Channel是双向通道，但是FileChannel根据获取源头判定可读或可写

FileInputStream获取，只可读

FileOutputStream获取，只可写

RandomAccessFile获取，可读、可写（双向通道）

* 文件流对象打开Channel，FileChannel是阻塞的

* @throws Exception

private static void channel() throws Exception{

FileInputStream in = new FileInputStream("C:\\Users\\zqq\\Desktop\\123.txt");

FileOutputStream out = new FileOutputStream("C:\\Users\\zqq\\Desktop\\321.txt");

//通过文件输入流创建通道channel

FileChannel channel = in.getChannel();

//获取FileChannel

FileChannel outChannel = out.getChannel();

//创建缓冲区byteBuffer

ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

//将管道channel中数据读取缓存区byteBuffer中，channel只能与Buffer交互

while (channel.read(byteBuffer) != -1){

//position设置为0，从头开始读

byteBuffer.flip();

outChannel.write(byteBuffer);

//byteBuffer 属性还原

byteBuffer.clear();

}

//关闭各种资源

channel.close();

out.flush();

out.close();

in.close();

out.close();

}

/**

* 静态方法打开Channel

* @throws Exception

public static void channel1() throws Exception{

// StandardOpenOption.READ ：读取一个已存在的文件，如果不存在或被占用抛出异常

// StandardOpenOption.WRITE ：以追加到文件头部的方式，写入一个已存在的文件，如果不存在或被占用抛出异常

// StandardOpenOption.APPEND：以追加到文件尾部的方式，写入一个已存在的文件，如果不存在或被占用抛出异常

// StandardOpenOption.CREATE：创建一个空文件，如果文件存在则不创建

// StandardOpenOption.CREATE_NEW：创建一个空文件，如果文件存在则报错

// StandardOpenOption.DELETE_ON_CLOSE：管道关闭时删除文件

//创建读通道

FileChannel inChannel = FileChannel.open(Paths.get("C:\\Users\\zqq\\Desktop\\123.txt"), StandardOpenOption.READ);

FileChannel outChannel = FileChannel.open(Paths.get("C:\\Users\\zqq\\Desktop\\321.txt"),

StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);

//内存映射

MappedByteBuffer inByteBuffer = inChannel.map(FileChannel.MapMode.READ_ONLY,0,inChannel.size());

MappedByteBuffer outByteBuffer = outChannel.map(FileChannel.MapMode.READ_WRITE,0,inChannel.size());

//直接对缓冲区数据读写

byte[] bytes = new byte[inByteBuffer.limit()];

inByteBuffer.get(bytes);//读取inByteBuffer内的数据,读到bytes数组中

outByteBuffer.put(bytes);//写入到outByteBuffer

inChannel.close();

outChannel.close();

}

RandomAccessFile打开通道Channel

/**

* 通过RandomAccessFile获取双向通道

* @throws Exception

private static void random() throws Exception{

try (RandomAccessFile randomAccessFile = new RandomAccessFile("D:\\workspace\\Demo\\test.txt","rw")){

//获取Channel

FileChannel fileChannel = randomAccessFile.getChannel();

//截取字节

//fileChannel.truncate(10);

//创建ByteBuffer，注意文件大小

ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

fileChannel.read(byteBuffer);

System.out.println(new String(byteBuffer.array(),"GBK"));

byteBuffer.clear();

String data = "this is data\r";

byteBuffer.put(data.getBytes());

byteBuffer.flip();//读写切换

while (byteBuffer.hasRemaining()){

fileChannel.write(byteBuffer);

}

//将通道数据强制写到磁盘

fileChannel.force(true);

}

FileChannel数据传输transferTo

/**

* 一个文件向另一个文件传输（copy）

private static void transferTo() {

try (

FileChannel inChannel = new FileInputStream("C:\\Users\\44141\\Desktop\\demo\\in.txt").getChannel();

FileChannel outChannel = new FileOutputStream("C:\\Users\\44141\\Desktop\\demo\\out.txt").getChannel()

){

//底层使用操作系统零拷贝进行优化，效率高。限制2g

inChannel.transferTo(0,inChannel.size(),outChannel);

}catch (Exception e){

e.printStackTrace();

}

/**

* 大于2g数据

private static void transferToGt2g() {

try (

FileChannel inChannel = new FileInputStream("C:\\Users\\44141\\Desktop\\demo\\in.txt").getChannel();

FileChannel outChannel = new FileOutputStream("C:\\Users\\44141\\Desktop\\demo\\out1.txt").getChannel()

){

//记录inChannel初始化大小

long size = inChannel.size();

//多次传输

for(long rsize = size; rsize > 0;){

//transferTo返回位移的字节数

rsize -= inChannel.transferTo((size-rsize),rsize,outChannel);

}

}catch (Exception e){

e.printStackTrace();

}

六、网络编程

阻塞模式

阻塞模式服务端每个方法都会阻塞等待客户端操作。比如accept()方法阻塞等待客户端连接，read()方法阻塞等待客户端传送数据，并发访问下没法高效的进行工作。

1.服务端代码

private static void server() throws Exception{

//1.创建服务器

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

//2.绑定监听端口

serverSocketChannel.bind(new InetSocketAddress(8080));

while (true){

System.out.println("开始监听连接=============" );

//4.accept 监听进来的连接返回SocketChannel对象,accept默认阻塞

SocketChannel socketChannel = serverSocketChannel.accept();

System.out.println("有连接连入===============" );

ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

// read()是阻塞方法，等客户端发送数据才会执行

socketChannel.read(byteBuffer);

byteBuffer.flip();

String str = StandardCharsets.UTF_8.decode(byteBuffer).toString();

System.out.println("接收到数据=============：" + str);

}

2.客户端代码

private static void client() throws Exception {

//1.创建客户端

SocketChannel socketChannel = SocketChannel.open();

//连接服务端

socketChannel.connect(new InetSocketAddress("localhost",8080));

//2 秒后写入数据

Thread.sleep(2 * 1000);

socketChannel.write(StandardCharsets.UTF_8.encode("nio"));

System.out.println();

}

非阻塞模式

服务端设置成非阻塞模式。客户端不用动。

private static void server() throws Exception{

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

//设置成非阻塞模式

serverSocketChannel.configureBlocking(false);

serverSocketChannel.bind(new InetSocketAddress(8080));

while (true){

SocketChannel socketChannel = serverSocketChannel.accept();

//非阻塞模式下，SocketChannel会返回为null

if(socketChannel != null){

//非阻塞模式

socketChannel.configureBlocking(false);

ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

socketChannel.read(byteBuffer);

byteBuffer.flip();

String str = StandardCharsets.UTF_8.decode(byteBuffer).toString();

System.out.println("接收到数据=============：" + str);

}

七、Selector

Selector选择器的作用就是配合一个线程来管理多个Channel，被Selector管理的Channel必须是非阻塞模式下的，所以Selector没法与FileChannel（FileChannel只有阻塞模式）一起使用。

创建Selector

创建Selector只需要调用一个静态方法

//创建Selector

Selector selector = Selector.open();

Selector可以用来监听Channel的事件，总共有四个事件：

accept：会在有连接请求时触发，静态常量 SelectionKey.OP_ACCEPT

connect：客户端建立连接后触发，静态常量 SelectionKey.OP_CONNECT

read：可读时触发，静态常量 SelectionKey.OP_READ

write：可写时触发，静态常量 SelectionKey.OP_WRITE

Selector与Channel绑定

//设置成非阻塞模式

serverSocketChannel.configureBlocking(false);

SelectionKey selectionKey = serverSocketChannel.register(selector,0,null);

//绑定关注的事件

selectionKey.interestOps(SelectionKey.OP_ACCEPT);

八、网络编程（多路复用）

1.客户端代码 SocketChannel

public static void main(String[] args) throws Exception {

client();

}

private static void client() throws Exception {

//1.创建客户端

SocketChannel socketChannel = SocketChannel.open();

//连接服务端

socketChannel.connect(new InetSocketAddress("localhost",8080));

//2 秒后写入数据

Thread.sleep(2 * 1000);

socketChannel.write(StandardCharsets.UTF_8.encode("nio"));

//3.读取服务端返回数据

ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

socketChannel.read(byteBuffer);

byteBuffer.flip();

System.out.println("服务端返回数据=======：" + StandardCharsets.UTF_8.decode(byteBuffer).toString());

//断开连接

socketChannel.close();

}

2.服务端代码

public static void main(String[] args) throws Exception{

server();

}

private static void server() throws Exception{

//创建Selector

Selector selector = Selector.open();

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

//设置成非阻塞模式

serverSocketChannel.configureBlocking(false);

//将Channel注册到selector上（绑定关系）

//当事件发生后可以根据SelectionKey知道哪个事件和哪个Channel的事件

SelectionKey selectionKey = serverSocketChannel.register(selector,0,null);

//selectionKey 关注ACCEPT事件（也可以在上面注册时用第二个参数设置）

selectionKey.interestOps(SelectionKey.OP_ACCEPT);

serverSocketChannel.bind(new InetSocketAddress(8080));

while (true){

System.out.println("阻塞====================");

// select方法没有事件发生时阻塞线程，有事件线程会恢复运行

selector.select();

System.out.println("开始处理事件=================");

// 处理事件

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

while (iterator.hasNext()){

SelectionKey sk = iterator.next();

//获取到SelectionKey对象之后，将集合内的引用删掉（Selecotr不会自动删除）

iterator.remove();

//取消事件，不操作（不处理或者不取消事件，selector.select()方法不会阻塞）

//sk.cancel();

//区分不同的事件做不同的动作

if(sk.isAcceptable()){ //有连接请求事件

//通过SelectionKey 获取对应的channel

ServerSocketChannel channel = (ServerSocketChannel) sk.channel();

SocketChannel socketChannel = channel.accept();

socketChannel.configureBlocking(false);

//读取数据内容,bytebuffer大小注意消息边界（一个字符串被分割读取多次出来结果不准确）

ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

//将socketChannel绑定Selector

SelectionKey socketKey = socketChannel.register(selector,0,byteBuffer);

//关注可读事件

socketKey.interestOps(SelectionKey.OP_READ);

}else if(sk.isReadable()){//可读事件

try {

//取到Channel

SocketChannel socketChannel = (SocketChannel) sk.channel();

//获取到绑定的ByteBuffer

ByteBuffer byteBuffer = (ByteBuffer) sk.attachment();

int read = socketChannel.read(byteBuffer);

//如果是正常断开 read = -1

if(read == -1){

//取消事件

sk.cancel();

continue;

}

byteBuffer.flip();

String str = StandardCharsets.UTF_8.decode(byteBuffer).toString();

System.out.println("服务端读取到数据===========：" + str);

//写数据回客户端

ByteBuffer writeBuffer = StandardCharsets.UTF_8.encode("this is result");

socketChannel.write(writeBuffer);

//如果数据一次没写完关注可写事件进行再次写入（大数据一次写不完的情况）

if(writeBuffer.hasRemaining()){

//关注可写事件，添加事件，用interestOps()方法获取到之前的事件加上可写事件（类似linux系统的赋权限 777）

sk.interestOps(sk.interestOps() + SelectionKey.OP_WRITE);

sk.attach(writeBuffer);

//位运算符也可以

//sk.interestOps(sk.interestOps() | SelectionKey.OP_WRITE);

}

}catch (IOException e){

e.printStackTrace();

//客户端异常断开连接，取消事件

sk.cancel();

}

}else if(sk.isWritable()){

//取到Channel

SocketChannel socketChannel = (SocketChannel) sk.channel();

//获取到绑定的ByteBuffer

ByteBuffer writeBuffer = (ByteBuffer) sk.attachment();

socketChannel.write(writeBuffer);

//如果全部写完，取消可写事件绑定，解除writeBuffer绑定

if(!writeBuffer.hasRemaining()){

sk.attach(null);

//取消可写事件

sk.interestOps(sk.interestOps() - SelectionKey.OP_WRITE);

}

c语言sscanf函数的用法是什么

249 2023-01-18

java基础之NIO介绍及使用

c语言sscanf函数的用法是什么

c语言一维数组怎么快速排列

linux怎么查看本机内存大小

推荐文章

api接口有哪几种分类及功能

什么是API接口?API接口简单介绍

短信API接口概述，短信API接口的优势

7款快递物流的物流查询API工具，物流快递查询API接口怎么对接？

企业四要素: 了解企业经营成功的关键

什么是语音验证码?,语音验证码平台有哪些

全国工商查询系统怎么查企业名录

哪些平台提供实名认证的接口？

PHP如何调用API接口?

如何使用百度天气预报API接口?

最近发表

热评文章

数据接口api（数据接口API开发平台）

数据开放接口api（数据服务api开发）

Python爬虫教程：爬取酷狗音乐（python爬取

hbuilder怎么更改字体大小和颜色

直播平台api接口 - 构建卓越的直播平台

实时股票数据api接口（股票实时行情api接口）