当前位置： 首页 > news >正文

详解Java中的BIO、NIO、AIO

news 来源：原创 2024/5/18 3:11:49

本文收录于JavaStarter ，里面有我完整的Java系列文章，学习或面试都可以看看

（一）引言

IO流是Java中比较难理解的一个知识点，但是IO流在实际的开发场景中经常会使用到，比如Dubbo底层就是NIO进行通讯。本文将介绍Java发展过程中出现的三种IO：BIO、NIO以及AIO，重点介绍NIO。

（二）什么是BIO

BIO即同步阻塞IO，实现模型为一个连接就需要一个线程去处理。这种方式简单来说就是当有客户端来请求服务器时，服务器就会开启一个线程去处理这个请求，即使这个请求不干任何事情，这个线程都一直处于阻塞状态。

BIO模型有很多缺点，最大的缺点就是资源的浪费。想象一下如果QQ使用BIO模型，当有一个人上线时就需要一个线程，即使这个人不聊天，这个线程也一直被占用，那再多的服务器资源都不管用。

（三）BIO代码实践

我们通过socket模拟BIO的实现逻辑

首先建立Server，建立一个ServerSocket对象，绑定端口，然后等待连接，如果连接成功就新建一个线程去处理连接。

public class server {
    private static Socket socket=null;
    public static void main(String[] args) {
        try {
            //绑定端口
            ServerSocket serverSocket=new ServerSocket();
            serverSocket.bind(new InetSocketAddress(8080));
            while (true){
                //等待连接  阻塞
                System.out.println("等待连接");
                socket = serverSocket.accept();
                System.out.println("连接成功");
                //连接成功后新开一个线程去处理这个连接
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        byte[] bytes=new byte[1024];
                        try {
                            System.out.println("等待读取数据");
                            //等待读取数据    阻塞
                            int length=socket.getInputStream().read(bytes);
                            System.out.println(new String(bytes,0,length));
                            System.out.println("数据读取成功");
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

接着建立Client代码

public class Client {
    public static void main(String[] args) {
        Socket socket= null;
        try {
            socket = new Socket("127.0.0.1",8080);
            socket.getOutputStream().write("一条数据".getBytes());
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端的代码就连接一个服务器，然后发出一条数据即可。

这样就实现了一个BIO,但是BIO的缺点实在太明显了，因此在JDK1.4的时候，NIO出现了。

（四）什么是NIO

BIO是阻塞的，如果没有多线程，BIO就需要一直占用CPU，而NIO则是非阻塞IO，NIO在获取连接或者请求时，即使没有取得连接和数据，也不会阻塞程序。NIO的服务器实现模式为一个线程可以处理多个请求（连接）。

NIO有几个知识点需要掌握，Channel(通道)，Buffer(缓冲区), Selector（多路复用选择器）。

Channel既可以用来进行读操作，又可以用来进行写操作。NIO中常用的Channel有FileChannel
、SocketChannel、ServerSocketChannel、DatagramChannel。

Buffer缓冲区用来发送和接受数据。

Selector 一般称为选择器或者多路复用器 。它是Java NIO核心组件中的一个，用于检查一个或多个NIO Channel（通道）的状态是否处于可读、可写。在javaNIO中使用Selector往往是将Channel注册到Selector中。

下面我通过代码的方式模拟javaNIO的运行流程。

（五）NIO代码实践

首先贴上NIO的实践代码：

NIO服务端详细的执行过程是这样的：

1、创建一个ServerSocketChannel和Selector，然后将ServerSocketChannel注册到Selector上

2、Selector通过select方法去轮询监听channel事件，如果有客户端要连接时，监听到连接事件。

3、通过channel方法将socketchannel绑定到ServerSocketChannel上，绑定通过SelectorKey实现。

4、socketchannel注册到Selector上，关心读事件。

5、Selector通过select方法去轮询监听channel事件，当监听到有读事件时，ServerSocketChannel通过绑定的SelectorKey定位到具体的channel，读取里面的数据。

public class NioServer {
    public static void main(String[] args) throws IOException {
        //创建一个socket通道，并且设置为非阻塞的方式
        ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.socket().bind(new InetSocketAddress(9000));
        //创建一个selector选择器，把channel注册到selector选择器上
        Selector selector=Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true){
            System.out.println("等待事件发生");
            selector.select();
            System.out.println("有事件发生了");
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                handle(key);
            }
        }

    }

    private static void handle(SelectionKey key) throws IOException {
        if (key.isAcceptable()){
            System.out.println("连接事件发生");
            ServerSocketChannel serverSocketChannel= (ServerSocketChannel) key.channel();
            //创建客户端一侧的channel，并注册到selector上
            SocketChannel socketChannel = serverSocketChannel.accept();
            socketChannel.configureBlocking(false);
            socketChannel.register(key.selector(),SelectionKey.OP_READ);
        }else if (key.isReadable()){
            System.out.println("数据可读事件发生");
            SocketChannel socketChannel= (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int len = socketChannel.read(buffer);
            if (len!=-1){
                System.out.println("读取到客户端发送的数据："+new String(buffer.array(),0,len));
            }
            //给客户端发送信息
            ByteBuffer wrap = ByteBuffer.wrap("hello world".getBytes());
            socketChannel.write(wrap);
            key.interestOps(SelectionKey.OP_READ|SelectionKey.OP_WRITE);
            socketChannel.close();
        }
    }
}

客户端代码：NIO客户端代码的实现比BIO复杂很多，主要的区别在于，NIO的客户端也需要去轮询自己和服务端的连接情况。

public class NioClient {
    public static void main(String[] args) throws IOException {
        //配置基本的连接参数
        SocketChannel channel=SocketChannel.open();
        channel.configureBlocking(false);
        Selector selector = Selector.open();
        channel.connect(new InetSocketAddress("127.0.0.1",9000));
        channel.register(selector, SelectionKey.OP_CONNECT);

        //轮询访问selector
        while(true){
            selector.select();
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                //连接事件发生
                if (key.isConnectable()){
                    SocketChannel socketChannel= (SocketChannel) key.channel();
                    //如果正在连接，则完成连接
                    if (socketChannel.isConnectionPending()){
                        socketChannel.finishConnect();
                    }
                    socketChannel.configureBlocking(false);
                    ByteBuffer buffer = ByteBuffer.wrap("客户端发送的数据".getBytes());
                    socketChannel.write(buffer);
                    socketChannel.register(selector,SelectionKey.OP_READ);
                }else if (key.isReadable()){
                    //读取服务端发送过来的消息
                    read(key);
                }
            }
        }
    }

    private static void read(SelectionKey key) throws IOException {
        SocketChannel socketChannel= (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(512);
        int len=socketChannel.read(buffer);
        if (len!=-1){
            System.out.println("客户端收到信息："+new String(buffer.array(),0,len));
        }
    }
}

效果大概是这样的：首先服务端等待事件发生，当客户端启动时，服务器端先接受到连接的请求，接着接受到数据读取的请求，读完数据后继续等待。

客户端发送数据后，获取到了来自服务端的回复。

在这里插入图片描述

（六）NIO总结

NIO通过一个Selector，负责监听各种IO事件的发生，然后交给后端的线程去处理。NIO相比与BIO而言，非阻塞体现在轮询处理上。BIO后端线程需要阻塞等待客户端写数据，如果客户端不写数据就一直处于阻塞状态。而NIO通过Selector进行轮询已注册的客户端，当有事件发生时才会交给后端去处理，后端线程不需要等待。

（七）什么是AIO

AIO是在JDK1.7中推出的新的IO方式–异步非阻塞IO，也被称为NIO2.0，AIO在进行读写操作时，直接调用API的read和write方法即可，这两种均是异步的方法，且完成后会主动调用回调函数。简单来讲，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。

Java提供了四个异步通道：AsynchronousSocketChannel、AsynchronousServerSocketChannel、AsynchronousFileChannel、AsynchronousDatagramChannel。

（八）AIO代码实践

服务器端代码：AIO的创建方式和NIO类似，先创建通道，再绑定，再监听。只不过AIO中使用了异步的通道。

public class AIOServer {
    public static void main(String[] args) {
        try {
            //创建异步通道
            AsynchronousServerSocketChannel serverSocketChannel=AsynchronousServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(8080));
            System.out.println("等待连接中");
            //在AIO中，accept有两个参数，
            // 第一个参数是一个泛型，可以用来控制想传递的对象
            // 第二个参数CompletionHandler，用来处理监听成功和失败的逻辑
            //  如此设置监听的原因是因为这里的监听是一个类似于递归的操作，每次监听成功后要开启下一个监听
            serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
                //请求成功处理逻辑
                @Override
                public void completed(AsynchronousSocketChannel result, Object attachment) {
                    System.out.println("连接成功，处理数据中");
                    //开启新的监听
                    serverSocketChannel.accept(null,this);
                    handledata(result);
                }
                @Override
                public void failed(Throwable exc, Object attachment) {
                    System.out.println("失败");
                }
            });
            try {
                TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handledata(AsynchronousSocketChannel result) {
        ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
        //通道的read方法也带有三个参数
        //1.目的地：处理客户端传递数据的中转缓存，可以不使用
        //2.处理客户端传递数据的对象
        //3.处理逻辑，也有成功和不成功的两个写法
        result.read(byteBuffer, byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                if (result>0){
                    attachment.flip();
                    byte[] array = attachment.array();
                    System.out.println(new String(array));
                }
            }
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("失败");
            }
        });
    }
}

客户端代码基本上没有太多差别，主要还是实现数据的发送功能

public class AIOClient {
    public static void main(String[] args) {
        try {
            AsynchronousSocketChannel socketChannel=AsynchronousSocketChannel.open();
            socketChannel.connect(new InetSocketAddress("127.0.0.1",8080));
            Scanner scanner=new Scanner(System.in);
            String next = scanner.next();
            ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
            byteBuffer.put(next.getBytes());
            byteBuffer.flip();
            socketChannel.write(byteBuffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

观察结果：

相关文章：

  • 取经阿里十年技术大佬，得到Java线上问题排查攻略！
  • Understanding memory usage on Linux
  • Java中的拦截器和过滤器有什么区别
  • 为什么要引入分布式任务调度系统？
  • 为什么说datax是目前最好的异构数据源数据交换工具
  • Java常用关键字：this、super、final、static、访问修饰符
  • JAVA UUID 生成唯一标识
  • 网络开发的最强大框架：Netty快速入门
  • 适配器模式详解与应用
  • 树莓派 - 使用须知
  • 粘包和半包有了解过吗？netty是如何解决这个问题的
  • 云计算与SOA之我见
  • 迭代器模式：理解与实践
  • [转]MySQL排序原理与案例分析
  • 深入浅出CMS垃圾收集器
  • 【个人向】《HTTP图解》阅后小结
  • HTML-表单
  • Java到底能干嘛？
  • Traffic-Sign Detection and Classification in the Wild 论文笔记
  • VirtualBox 安装过程中出现 Running VMs found 错误的解决过程
  • Vue.js源码（2）：初探List Rendering
  • vue从创建到完整的饿了么（18）购物车详细信息的展示与删除
  • 精益 React 学习指南 （Lean React）- 1.5 React 与 DOM
  • 面试总结JavaScript篇
  • 手机端车牌号码键盘的vue组件
  • 思否第一天
  • 微信如何实现自动跳转到用其他浏览器打开指定页面下载APP
  • 自制字幕遮挡器
  • elasticsearch-head插件安装
  • Salesforce和SAP Netweaver里数据库表的元数据设计
  • #162 (Div. 2)
  • (ctrl.obj) : error LNK2038: 检测到“RuntimeLibrary”的不匹配项: 值“MDd_DynamicDebug”不匹配值“
  • （超详细）语音信号处理之特征提取
  • （附源码）springboot建达集团公司平台 毕业设计 141538
  • （一）eclipse Dynamic web project 工程目录以及文件路径问题
  • (转)视频码率,帧率和分辨率的联系与区别
  • (转载)虚函数剖析
  • .NET I/O 学习笔记：对文件和目录进行解压缩操作
  • .Net Redis的秒杀Dome和异步执行
  • .NET 程序如何获取图片的宽高（框架自带多种方法的不同性能）
  • .net 后台导出excel ,word
  • .net 流——流的类型体系简单介绍
  • .net项目IIS、VS 附加进程调试
  • .php文件都打不开,打不开php文件怎么办
  • /etc/apt/sources.list 和 /etc/apt/sources.list.d
  • [20171106]配置客户端连接注意.txt
  • [Angular] 笔记 16：模板驱动表单 - 选择框与选项
  • [c]统计数字
  • [C++][基础]1_变量、常量和基本类型
  • [CareerCup][Google Interview] 实现一个具有get_min的Queue
  • [elastic 8.x]java客户端连接elasticsearch与操作索引与文档
  • [element-ui] el-dialog 中的内容没有预先加载，因此无法获得内部元素的ref 的解决方案
  • [flask] flask的基本介绍、flask快速搭建项目并运行
  • [FUNC]判断窗口在哪一个屏幕上
  • [HDU]2161Primes