【深入理解Java】一篇文章带你彻底吃透Java NIO

目录

• • 一、Java思维导图
  • 二、I/O模型
  • 三、BIO、NIO、AIO应用场景
  • 四、BIO编程简单流程
  • 五、NIO核心
  • 六、BIO与NIO比较
  • 七、NIO 三大核心原理示意图
  • 八、缓冲区（buffer）
  • • 1、常用Buffer子类一览
    • 2、buffer四大属性
    • 3、buffer常用api
  • 九、通道（channel）
  • • 1、基本介绍
    • 2、FileChannel
    • 3、关于Buffer 和 Channel的注意事项和细节
  • 十、Selector(选择器)
  • • 1、基本介绍
    • 2、selector的相关方法
    • 3、注意事项
  • 十一、通过NIO实现简单的服务端客户端通信
  • • 1、服务端
    • 2、客户端
    • 3、控制台输出
  • 十二、我愿称你为最强
  • 十三、关注公众号哪吒编程，回复1024，获取Java学习资料，还有不定期的送书活动

一、Java思维导图

二、I/O模型

I/O模型的本质是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。
Java共支持三种网络编程模型：BIO、NIO、AIO

1. BIO：同步并阻塞，服务实现模式为一个连接一个线程，即客户端有一个连接请求时，服务端就需要启动一个线程进行处理。
2. NIO： 同步非阻塞，服务器实现模式为一个线程处理多个请求连接，即客户端发送的请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理。
3. AIO：异步非阻塞，AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端。

三、BIO、NIO、AIO应用场景

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

四、BIO编程简单流程

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

五、NIO核心

NIO 有三大核心部分：Selector(选择器)、Channel(通道)、Buffer(缓冲区)。
NIO是面向缓冲区，或者说面向块编程，数据读取到一个 它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就 增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。
HTTP2.0使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求 的数量比HTTP1.1大了好几个数量级。
简而言之，NIO可以一个线程处理多个请求。

六、BIO与NIO比较

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

七、NIO 三大核心原理示意图

流程图说明：

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

八、缓冲区（buffer）

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

1、常用Buffer子类一览

1. ByteBuffer，存储字节数据到缓冲区；
2. ShortBuffer，存储字符串数据到缓冲区；
3. CharBuffer，存储字符数据到缓冲区；
4. IntBuffer，存储整数数据到缓冲区；
5. LongBuffer，存储长整型数据到缓冲区；
6. DoubleBuffer，存储小数到缓冲区；
7. FloatBuffer，存储小数到缓冲区；

2、buffer四大属性

1. mark：标记
2. position：位置，下一个要被读或写的元素的索引， 每次读写缓冲区数据时都会改变改值， 为下次读写作准备。
3. limit：表示缓冲区的当前终点，不能对缓冲区 超过极限的位置进行读写操作。且极限 是可以修改的
4. capacity：容量，即可以容纳的最大数据量；在缓 冲区创建时被设定并且不能改变。

3、buffer常用api

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();//告知此缓冲区是否为直接缓冲区

九、通道（channel）

1、基本介绍

（1）NIO的通道类似于流

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

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

2、FileChannel

FileChannel主要用来对本地文件进行 IO 操作，常见的方法有：

1. read，从通道读取数据并放到缓冲区中
2. write，把缓冲区的数据写到通道中
3. transferFrom，从目标通道 中复制数据到当前通道
4. transferTo，把数据从当 前通道复制给目标通道

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

1. ByteBuffer 支持类型化的put 和 get, put 放入的是什么数据类型，get就应该使用 相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。
2. 可以将一个普通Buffer 转成只读Buffer。
3. NIO 还提供了 MappedByteBuffer， 可以让文件直接在内存（堆外的内存）中进 行修改， 而如何同步到文件由NIO 来完成。
4. NIO 还支持 通过多个 Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 和 Gathering。

十、Selector(选择器)

1、基本介绍

1. Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连 接，就会使用到Selector(选择器)。
2. Selector 能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然 后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个 通道，也就是管理多个连接和请求。
3. 只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少 了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。
4. 避免了多线程之间的上下文切换导致的开销。

2、selector的相关方法

1. open();//得到一个选择器对象
2. select(long timeout);//监控所有注册的通道，当其 中有 IO 操作可以进行时，将 对应的 SelectionKey 加入到内部集合中并返回，参数用来 设置超时时间
3. selectedKeys();//从内部集合中得 到所有的 SelectionKey。

3、注意事项

NIO中的 ServerSocketChannel功能类似ServerSocket，SocketChannel功能类 似Socket。

十一、通过NIO实现简单的服务端客户端通信

1、服务端

package com.nezha.guor.nio;import java.io.IOException;import java.net.InetSocketAddress;import java.nio.ByteBuffer;import java.nio.channels.*;import java.util.Iterator;public class NioServer {    private Selector selector;    private ServerSocketChannel serverSocketChannel;    private static final int PORT = 8080;    public NioServer() {        try {            //获得选择器            selector = Selector.open();            serverSocketChannel =  ServerSocketChannel.open();            //绑定端口            serverSocketChannel.socket().bind(new InetSocketAddress(PORT));            //设置非阻塞模式            serverSocketChannel.configureBlocking(false);            //将该ServerSocketChannel 注册到selector            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);        }catch (IOException e) {            System.out.println("NioServer error:"+e.getMessage());        }    }    public void listen() {        System.out.println("监听线程启动: " + Thread.currentThread().getName());        try {            while (true) {                int count = selector.select();                if(count > 0) {                    //遍历得到selectionKey集合                    Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();                    while (iterator.hasNext()) {                        SelectionKey key = iterator.next();                        if(key.isAcceptable()) {                            SocketChannel sc = serverSocketChannel.accept();                            sc.configureBlocking(false);                            sc.register(selector, SelectionKey.OP_READ);                            System.out.println(sc.getRemoteAddress() + " 上线 ");                        }                        //通道发送read事件，即通道是可读的状态                        if(key.isReadable()) {                            getDataFromChannel(key);                        }                        //当前的key 删除，防止重复处理                        iterator.remove();                    }                } else {                    System.out.println("等待中");                }            }        }catch (Exception e) {            System.out.println("listen error:"+e.getMessage());        }    }    private void getDataFromChannel(SelectionKey key) {        SocketChannel channel = null;        try {            channel = (SocketChannel) key.channel();            ByteBuffer buffer = ByteBuffer.allocate(1024);            int count = channel.read(buffer);            //根据count的值做处理            if(count > 0) {                String msg = new String(buffer.array());                System.out.println("来自客户端: " + msg);                //向其它的客户端转发消息(排除自己)                sendInfoToOtherClients(msg, channel);            }        }catch (IOException e) {            try {                System.out.println(channel.getRemoteAddress() + " 离线了");                //取消注册                key.cancel();            }catch (IOException ex) {                System.out.println("getDataFromChannel error:"+ex.getMessage());            }        }finally {            try {                channel.close();            }catch (IOException ex) {                System.out.println("channel.close() error:"+ex.getMessage());            }        }    }    //转发消息给其它客户(通道)    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()) {            Channel targetChannel = key.channel();            //排除自己            if(targetChannel instanceof  SocketChannel && targetChannel != self) {                SocketChannel dest = (SocketChannel)targetChannel;                //将信息存储到buffer                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());                //将buffer数据写入通道                dest.write(buffer);            }        }    }    public static void main(String[] args) {        //创建服务器对象        NioServer nioServer = new NioServer();        nioServer.listen();    }}

2、客户端

package com.nezha.guor.nio;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 NioClient {    private final int PORT = 8080; //服务器端口    private Selector selector;    private SocketChannel socketChannel;    private String username;    public NioClient() throws IOException {        selector = Selector.open();        socketChannel = socketChannel.open(new InetSocketAddress("127.0.0.1", PORT));        //设置非阻塞        socketChannel.configureBlocking(false);        //将channel注册到selector        socketChannel.register(selector, SelectionKey.OP_READ);        username = socketChannel.getLocalAddress().toString().substring(1);        System.out.println(username + " is ok...");    }    //向服务器发送消息    public void sendInfo(String info) {        info = username + " 说：" + info;        try {            socketChannel.write(ByteBuffer.wrap(info.getBytes()));        }catch (IOException e) {            System.out.println("sendInfo error:"+e.getMessage());        }    }    //读取从服务器端回复的消息    public void readInfo() {        try {            int readChannels = selector.select();            if(readChannels > 0) {                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();                while (iterator.hasNext()) {                    SelectionKey key = iterator.next();                    if(key.isReadable()) {                        //得到相关的通道                        SocketChannel sc = (SocketChannel) key.channel();                        //得到一个Buffer                        ByteBuffer buffer = ByteBuffer.allocate(1024);                        //读取                        sc.read(buffer);                        //把读到的缓冲区的数据转成字符串                        String msg = new String(buffer.array());                        System.out.println(msg.trim());                    }                }                iterator.remove(); //删除当前的selectionKey, 防止重复操作            } else {                System.out.println("没有可以用的通道...");            }        }catch (Exception e) {            System.out.println("readInfo error:"+e.getMessage());        }    }    public static void main(String[] args) throws Exception {        NioClient nioClient = new NioClient();        new Thread() {            public void run() {                while (true) {                    nioClient.readInfo();                    try {                        Thread.currentThread().sleep(2000);                    }catch (InterruptedException e) {                        System.out.println("sleep error:"+e.getMessage());                    }                }            }        }.start();        //发送数据给服务器端        Scanner scanner = new Scanner(System.in);        while (scanner.hasNextLine()) {            nioClient.sendInfo(scanner.nextLine());        }    }}

3、控制台输出

十二、我愿称你为最强

Java学习路线总结（思维导图篇）
【Java基础知识 1】Java入门级概述
【Java基础知识 2】配置java环境变量
【Java基础知识 3】为何要配置环境变量？
【Java基础知识 4】秒懂数组拷贝，感知新境界
【Java基础知识 5】装箱和拆箱
【Java基础知识 6】Java异常详解
【Java基础知识 7】toString()、String.valueOf、(String)强转
【Java基础知识 8】String、StringBuilder、StringBuffer详解
【Java基础知识 9】序列化与反序列化
【Java基础知识 10】Java IO流详解
【Java基础知识 11】java泛型方法的定义和使用
【Java基础知识 12】java枚举详解
【Java基础知识 13】java注解详解
【Java基础知识 14】java动态代理原理
【Java基础知识 15】java反射机制原理详解
【Java基础知识 16】java内部类使用场景
更多精彩内容，尽在哪吒

十三、关注公众号哪吒编程，回复1024，获取Java学习资料，还有不定期的送书活动

1. Javascript从入门到精通
2. 从基础到中台微服务实战开发
3. 微信小程序从入门到实战
4. Python自然语言处理入门