这篇文章主要介绍了Java中NIO的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。

创新互联主要从事网站设计、网站制作、网页设计、企业做网站、公司建网站等业务。立足成都服务湖南,10多年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18980820575

一、Java思维导图

二、I/O模型

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

• BIO：同步并阻塞，服务实现模式为一个连接一个线程，即客户端有一个连接请求时，服务端就需要启动一个线程进行处理。

• NIO： 同步非阻塞，服务器实现模式为一个线程处理多个请求连接，即客户端发送的请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理。

• AIO：异步非阻塞，AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端。

三、BIO、NIO、AIO应用场景

• BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高， 并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解。

• NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕 系统，服务器间通讯等。编程比较复杂，JDK1.4开始支持。

• AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分 调用OS参与并发操作，编程比较复杂，JDK7开始支持

四、BIO编程简单流程

• 服务器端启动一个ServerSocket；

• 客户端启动Socket对服务器进行通 信，默认情况下服务器端需要对每 个客户 建立一个线程与之通讯；

• 客户端发出请求后, 先咨询服务器 是否有线程响应，如果没有则会等 待，或者被拒绝；

• 如果有响应，客户端线程会等待请 求结束后，在继续执行；

五、NIO核心

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

六、BIO与NIO比较

• BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多；

• BIO 是阻塞的，NIO 则是非阻塞的；

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

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

流程图说明：

• Selector 对应一个线程， 一个线程对应多个channel(连接)；

• 该图反应了有三个channel 注册到 该selector //程序；

• 每个channel 都会对应一个Buffer；

• 程序切换到哪个channel 是有事件决定的, Event 就是一个重要的概念；

• Selector 会根据不同的事件，在各个通道上切换；

• Buffer 就是一个内存块 ， 底层是有一个数组；

• 数据的读取写入是通过Buffer, 这个和BIO , BIO 中要么是输入流，或者是 输出流, 不能双向，但是NIO的Buffer 是可以读也可以写, 需要 flip 方法切换；

• channel 是双向的, 可以返回底层操作系统的情况, 比如Linux ， 底层的操作系统 通道就是双向的；

八、缓冲区（buffer）

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

1、常用Buffer子类一览

• ByteBuffer，存储字节数据到缓冲区；

• ShortBuffer，存储字符串数据到缓冲区；

• CharBuffer，存储字符数据到缓冲区；

• IntBuffer，存储整数数据到缓冲区；

• LongBuffer，存储长整型数据到缓冲区；

• DoubleBuffer，存储小数到缓冲区；

• FloatBuffer，存储小数到缓冲区；

2、buffer四大属性

• mark：标记

• position：位置，下一个要被读或写的元素的索引， 每次读写缓冲区数据时都会改变改值， 为下次读写作准备。

• limit：表示缓冲区的当前终点，不能对缓冲区 超过极限的位置进行读写操作。且极限 是可以修改的

• 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 操作，常见的方法有：

• read，从通道读取数据并放到缓冲区中

• write，把缓冲区的数据写到通道中

• transferFrom，从目标通道 中复制数据到当前通道

• transferTo，把数据从当 前通道复制给目标通道

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

• ByteBuffer 支持类型化的put 和 get, put 放入的是什么数据类型，get就应该使用 相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。

• 可以将一个普通Buffer 转成只读Buffer。

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

• NIO 还支持 通过多个 Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 和 Gathering。

十、Selector(选择器)

1、基本介绍

• Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连 接，就会使用到Selector(选择器)。

• Selector 能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然 后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个 通道，也就是管理多个连接和请求。

• 只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少 了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。

• 避免了多线程之间的上下文切换导致的开销。

2、selector的相关方法

• open();//得到一个选择器对象

• select(long timeout);//监控所有注册的通道，当其 中有 IO 操作可以进行时，将 对应的 SelectionKey 加入到内部集合中并返回，参数用来 设置超时时间

• 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 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 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中NIO的示例分析”这篇文章对大家有帮助，同时也希望大家多多支持创新互联，关注创新互联行业资讯频道，更多相关知识等着你来学习!

名称栏目：Java中NIO的示例分析
分享路径：http://azwzsj.com/article/gpehci.html