Java NIO 编程

Posted 2022-12-07 丶落幕

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java NIO 编程相关的知识，希望对你有一定的参考价值。

Java NIO 编程

1 I/O模型基本说明
2 BIO、NIO、AIO适用场景分析
3 Java BIO 基本介绍
- 3.1 Java BIO 应用实例
- 3.2 Java BIO 问题分析
4 Java NIO 基本介绍
5 Java AIO 基本介绍
总结

1 I/O模型基本说明

I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能
Java共支持3种网络编程模型/IO模式：BIO、NIO、AIO
Java BIO ：同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销
Java NIO ：同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理
Java AIO(NIO.2) ：异步非阻塞，AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程

2 BIO、NIO、AIO适用场景分析

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解。
NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK1.4开始支持。
AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

3 Java BIO 基本介绍

Java BIO 就是传统的java io 编程，其相关的类和接口在 java.io
BIO(blocking I/O) ：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)。
BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，程序简单易理解

工作原理图

BIO编程简单流程

服务器端启动一个ServerSocket
客户端启动Socket对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯
客户端发出请求后, 先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝
如果有响应，客户端线程会等待请求结束后，在继续执行

3.1 Java BIO 应用实例

public class Bioserver 
    public static void main(String[] args) throws IOException 
        //思路
        //1. 创建一个线程池
        //2. 如果有客户端连接,就创建一个线程,与之通讯(单独写一个方法)
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        //创建
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("======服务器启动======");
        while (true) 
            //监听,等待客户端连接
            System.out.println("等待连接....");
            final Socket socket = serverSocket.accept();
            System.out.println("======连接到一个客户端======");
            cachedThreadPool.execute(() -> 
                handler(socket);
            );
        
    
    //编写一个handler方法,和客户端通讯
    public static void handler(Socket socket)
        byte[] bytes = new byte[1024];
        System.out.println("线程信息 id="+Thread.currentThread().getId()+"name"+Thread.currentThread().getName());
        try 
            InputStream inputStream = socket.getInputStream();
            //循环的读取客户端发送的数据
            while (true)
                System.out.println("线程信息 id="+Thread.currentThread().getId()+"name"+Thread.currentThread().getName());
                System.out.println("read....");
                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 
                if(socket!=null)socket.close();
             catch (IOException e) 
                e.printStackTrace();

使用telnet连接服务端(cmd命令)

如果提示没有telnet命令,百度,开启telnet

#连接地址
telnet 127.0.0.1 6666
#建立接连
CTRL + ]
#发送消息
send 消息

3.2 Java BIO 问题分析

每个请求都需要创建独立的线程，与对应的客户端进行数据 Read，业务处理，数据 Write 。
当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大。
连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费

4 Java 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是面向缓冲区，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络
Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。
通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有10000个请求过来, 根据实际情况，可以分配50或者100个线程来处理。不像之前的阻塞IO那样，非得分配10000个。
HTTP2.0使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比HTTP1.1大了好几个数量级。

4.1 NIO 和 BIO 的比较

BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多
BIO 是阻塞的，NIO 则是非阻塞的
BIO基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。 Selector(选择器)用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道

4.2 NIO 三大核心原理示意图

每个channel 都会对应一个Buffer
Selector 对应一个线程，一个线程对应多个channel(连接)
该图反应了有三个channel 注册到该selector //程序
程序切换到哪个channel 是有事件决定的, Event 就是一个重要的概念
Selector 会根据不同的事件，在各个通道上切换
Buffer 就是一个内存块，底层是有一个数组
数据的读取写入是通过Buffer, 这个和BIO , BIO 中要么是输入流，或者是输出流, 不能双向，但是NIO的Buffer 是可以读也可以写, 需要 flip 方法切换
channel 是双向的, 可以返回底层操作系统的情况, 比如Linux ，底层的操作系统通道就是双向的.

4.3 缓冲区(Buffer)

基本介绍

缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，如图:

Buffer 类及其子类

ByteBuffer，存储字节数据到缓冲区
ShortBuffer，存储字符串数据到缓冲区
CharBuffer，存储字符数据到缓冲区
IntBuffer，存储整数数据到缓冲区
LongBuffer，存储长整型数据到缓冲区
DoubleBuffer，存储小数到缓冲区
FloatBuffer，存储小数到缓冲区

Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:

属性	描述
Capacity	容量，即可以容纳的最大数据量；在缓冲区创建时被设定并且不能改变
Limit	表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的
Position	位置，下一个要被读或写的元素的索引，每次读写缓冲区数据时都会改变改值，为下次读写作准备
Mark	标记

Buffer类相关方法一览

public abstract class Buffer 
	//JDK1.4时，引入的api
	public 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时引入的api
	public abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组
	public abstract Object array();//返回此缓冲区的底层实现数组
	public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
	public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区

ByteBuffer

从前面可以看出对于 Java 中的基本数据类型(boolean除外)，都有一个 Buffer 类型与之相对应，最常用的自然是ByteBuffer 类（二进制数据），该类的主要方法如下：

public abstract class ByteBuffer 
	//缓冲区创建相关api
	public 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)
	//缓存区存取相关API
	public abstract byte get( );//从当前位置position上get，get之后，position会自动+1
	public abstract byte get (int index);//从绝对位置get
	public abstract ByteBuffer put (byte b);//从当前位置上添加，put之后，position会自动+1
	public abstract ByteBuffer put (int index, byte b);//从绝对位置上put

4.4 通道(Channel)

基本介绍

NIO的通道类似于流，但有些区别如下：

通道可以同时进行读写，而流只能读或者只能写
通道可以实现异步读写数据
通道可以从缓冲读数据，也可以写数据到缓冲:

BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道 (Channel)是双向的，可以读操作，也可以写操作。
Channel在NIO中是一个接口 public interface Channel extends Closeable
常用的 Channel 类有：FileChannel、 DatagramChannel、ServerSocketChannel 和 SocketChannel。【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】
FileChannel 用于文件的数据读写， DatagramChannel 用于 UDP 的数据读写， ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。

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)，把数据从当前通道复制给目标通道

应用实例1-本地文件写数据

public class NIOFileChannel01 
    public static void main(String[] args) throws IOException 
        String str = "hello,world";
        //创建一个输出流-->channel
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\\\file01.txt");
        //通过fileOutputStream 获取 对应的 fileChannel
        FileChannel fileChannel = fileOutputStream.getChannel();
        //创建一个缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        byteBuffer.put(str.getBytes());
        //对byteBuffer进行反转
        byteBuffer.flip();
        //将byteBuffer数据写入到fileChannel
        fileChannel.write(byteBuffer);
        fileOutputStream.close();

应用实例2-本地文件读数据

public class NIOFileChannel02 
    public static void main(String[] args) throws IOException 
        File file=new File("d:\\\\file01.txt");
        FileInputStream fileInputStream = new FileInputStream(file);
        FileChannel channel = fileInputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
        channel.read(byteBuffer);
        //将byteBuffer的字节数据 转成string
        System.out.println(new String(byteBuffer.array()));
        fileInputStream.close();

应用实例3-使用一个Buffer完成文件读取

public class NIOFileChannel03 
    public static void main(String[] args) throws IOException 
        FileInputStream fileInputStream=new FileInputStream("d:\\\\file01.txt");
        FileChannel inChannel = fileInputStream.getChannel();
        FileOutputStream fileOutputStream=new FileOutputStream("d:\\\\file02.txt");
        FileChannel outChannel = fileOutputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        while (true)
            //需要复位(重置标志位)!!!
            byteBuffer.clear();
            int read = inChannel.read(byteBuffer);
            if(read==-1)
                break;
            
            //将Buffer中的数据写入到outChannel
            byteBuffer.flip();
            outChannel.write(byteBuffer);
        
        fileOutputStream.close();
        fileInputStream.close();

应用实例4-拷贝文件transferFrom 方法

public class NIOFileChannel04 
    public static void main(String[] args) throws IOException 
        FileInputStream fileInputStream = new FileInputStream("d:\\\\Koala.jpg");
        FileChannel inChannel = fileInputStream.getChannel();
        FileOutputStream fileOutputStream = new FileOutputStream("Koala.jpg");
        FileChannel outChannel = fileOutputStream.getChannel();
        //二者等价
        //inChannel.transferTo(0, inChannel.size(), outChannel);
        outChannel.transferFrom(inChannel, 0, inChannel.size());
        outChannel.close();
        fileOutputStream.close();
        inChannel.close();
        fileInputStream.close();

关于Buffer 和 Channel的注意事项和细节

ByteBuffer 支持类型化的put 和 get, put 放入的是什么数据类型，get就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。
可以将一个普通Buffer 转成只读Buffer

ByteBuffer readOnlyBuffer = byteBuffer.asReadOnlyBuffer();

NIO 还提供了 MappedByteBuffer，可以让文件直接在内存（堆外的内存）中进行修改，而如何同步到文件由NIO 来完成.

public class MappedByteBuffer_Demo 
    public static void main(String[] args) throws IOException 
        //rw代表读写
        RandomAccessFile randomAccessFile = new RandomAccessFile("file01.txt", "rw");
        //获取对应的通道
        FileChannel channel = randomAccessFile.getChannel();
        /*
         * 参数1: 使用读写模式
         * 参数2: 可以直接修改的起始位置
         * 参数3: 映射到内存的大小,即将1.txt的多少个字节映射到内存
         * */
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);
        mappedByteBuffer.put(0, (byte) 'H');
        mappedByteBuffer.put(3, (byte) '9');
        randomAccessFile.close();

前面我们讲的读写操作，都是通过一个Buffer 完成的，NIO 还支持通过多个 Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 和 Gathering

public class ScatteringAndGathering 
    public static void main(String[] args) throws IOException 
        //使用serversocketchannel 和 socketchannel网络
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);
        //绑定端口到socket并启动
        serverSocketChannel.socket().bind(inetSocketAddress);
        //创建Buffer数组
        ByteBuffer[] byteBuffers = new ByteBuffer[2];
        byteBuffers[0] = ByteBuffer.allocate(5);
        byteBuffers[1] = ByteBuffer.allocate(3);
        //等待客户端连接
        SocketChannel socketChannel = serverSocketChannel.accept();
        long messageLenght=8;
        while (true)
            long byteRead=0;
            while (byteRead<messageLenght)
                long l = socketChannel.read(byteBuffers);
                byteRead+=l;//累计读取的字节数
                System.out.println("byteRead="+byteRead);
                //使用流打印,看看当前的这个Buffer的position和limit
                Arrays.stream(byteBuffers)
                        .map(buffer->"position:"+buffer.position()+",limit="+buffer.limit())
                        .forEach(System.out::println);
            
            //将所有的Buffer进行flip
            Arrays.asList(byteBuffers).forEach(Buffer::flip);
            //将数据读出显示到客户端
            long byteWirte=0;
            while (byteWirte<messageLenght)
                long l = socketChannel.write(byteBuffers);
                byteWirte+=l;
            
            //将所有的Buffer进行clear
            Arrays.asList(byteBuffers).forEach(Buffer::clear);
            System.out.println("byteRead="+byteRead+",byteWirte="+byteWirte+",messageLenght="+messageLenght);

4.5 Selector(选择器)

基本介绍

Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector(选择器)
Selector 能够检测多个注册的通道上是否有事件发生(注意:多个Channel以事件的方式可以注册到同一个Selector)，如果有事件发生，便获取事件然后针对每
以上是关于Java NIO 编程的主要内容，如果未能解决你的问题，请参考以下文章

Java NIO Socket编程实例

一站式学习Java网络编程全面理解BIO/NIO/AIO

java.nio.ByteBuffer中flip,rewind,clear方法的区别

Java NIO 读取文件写入文件读取写入混合

java BIO/NIO/AIO 学习

Java网络编程和NIO详解9：基于NIO的网络编程框架Netty