聊聊java中NIO的2.0版本AIO

简介: 在2011年7月28日,jdk1.7被正式发布。他的一个最大的亮点就是将原来的NIO类库生成到了NIO2.0,也被叫做AIO。这篇文章将通过案例对AIO进行一个讲解。

一、IO的演进


在jdk1.4之前,java中的IO类库实在是超级原始,很多我们现在熟知的概念都还没有出现,比如说管道、缓冲区等等。正是由于这些等等原因,C语言和C++一直都是IO方面的首选。这是原始的IO方式,也叫作BIO,它的原理很简单,我们使用一张图来表示一下:

v2-97d3a5c1786fd53bcaf3c0d6d8da726c_1440w.jpg也就是说BIO时代,每次有一个客户端连接进来的时候,都会有一个新的线程去处理,缺点显而易见,如果连接比较多的时候,我们就要建立大量的线程去一一处理。


几年之后,2002年,jdk1.4开始被正式发布了,做出的一个巨大的改变就是新增了NIO包。它提供了很多异步的IO操作方法,比如说缓冲区ByteBuffer、Pipe、Channel还有多路复用器Selector等等。新的NIO类库的出现,极大地促进了java对异步非阻塞式编程的发展。NIO的原理也是很简单。在这里同样使用一张图来演示一遍:

v2-ceab78ec37e55d5cc79047e2e689297d_1440w.jpg

现在我们可以看到,所有的客户端连接都可以只用一个线程就可以实现了。


不过时代总是在一点一点的变化,逐渐的java官方为我们提供的NIO类库越来越不能满足需求,比如说不支持异步文件读写操作、没有统一的文件属性等等。于是过了几年,在2011年7月28日,官方将用了将近十年的NIO类库做了升级,也被称为NIO2.0。后来也叫作AIO。AIO的原理是在之前的基础上进行的改进,意思是异步非阻塞式IO,也就是说你的客户端在进行读写操作的时候,只需要给服务器发送一个请求,不用一直等待回答就可以去做其他的事了。


下面我们使用代码敲一遍来看看如何实现AIO。


二、AIO的实现


这个案例很简单,就是服务端和客户端一个简单的通信。我们先把代码写好,然后再去分析代码的含义。


1、服务端


第一步:定义Server启动类

class AioServer{
    public static void main(String[] args){
        new AioServerHandle().start();   
        try {
            Thread.sleep(10000000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 }

在这里我们定义了一个AioServerHandle线程去处理服务器端的逻辑,在这里我们还休眠了很长时间,这是为了避免没有客户端连接时,程序运行结束。现在我们最主要的就是AioServerHandle的代码逻辑了。


第二步:AioServerHandle类实现

public class AioServerHandle extends Thread {
    AsynchronousServerSocketChannel serverSocketChannel;
    public AioServerHandle() {
        try {
            serverSocketChannel = AsynchronousServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress("127.0.0.1", 8888));    
            System.out.println("服务端初始化成功");
        } catch (IOException e) {
            e.printStackTrace();
        }         
    }
    @Override
    public void run() {
        serverSocketChannel.accept(this, new AcceptCompleteHandler(serverSocketChannel));
        try {
            Thread.sleep(100000000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

我们分析一下这段代码,首先我们定义了一个AsynchronousServerSocketChannel,他表示的就是异步的ServerSocketChannel。然后我们在构造方法中打开连接,绑定地址和端口。最后再run方法中new了一个AcceptCompleteHandler来处理接入的客户端。现在就像踢皮球一样,真正的处理逻辑又给了新的类AcceptCompleteHandler,我们再来看。


第三步:AcceptCompleteHandler的实现


public class AcceptCompleteHandler implements CompletionHandler<AsynchronousSocketChannel, AioServerHandle> {
    //第一部分
    private AsynchronousServerSocketChannel serverSocketChannel;
    public AcceptCompleteHandler(AsynchronousServerSocketChannel serverSocketChannel) {
        this.serverSocketChannel = serverSocketChannel;
    }
    //第二部分
    @Override
    public void completed(final AsynchronousSocketChannel channel, AioServerHandle attachment) {
        //第二部分第一小节
        attachment.serverSocketChannel.accept(attachment, this);
        System.out.println("有客户端链接进来");
        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
        //第二部分第二小节
        channel.read(readBuffer, readBuffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                attachment.flip();
                byte[] bytes = new byte[attachment.remaining()];
                attachment.get(bytes);
                System.out.println("客户端发送来的数据是:" + new String(bytes));
                String sendMsg = "服务端返回的数据:java的架构师技术栈";
                ByteBuffer writeBuffer = ByteBuffer.allocate(sendMsg.getBytes().length);
                writeBuffer.put(sendMsg.getBytes());
                writeBuffer.flip();
                channel.write(writeBuffer, writeBuffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        if (attachment.hasRemaining()) {
                            channel.write(attachment, attachment, this);
                        }
                    }
                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        try {
                            System.out.println("服务端出现写数据异常");
                            channel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
            //第二部分第三小节
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                try {
                    System.out.println("服务端读取数据异常");
                    serverSocketChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    //第三部分
    @Override
    public void failed(Throwable exc, AioServerHandle attachment) {
        System.out.println("服务端链接异常");
    }
}

第一部分:


通过构造方法来接受传递过来的AsynchronousServerSocketChannel。


第二部分第一小节:


serverSocketChannel继续接受传递过来的客户端,为什么呢?因为调用了AsynchronousServerSocketChannel的accept方法之后,如果有新的客户端连接进来,系统会回调我们的CompletionHandler得completed方法。但是一个AsynchronousServerSocketChannel往往能接受成千上万个客户端,所以在这里继续调用了Accept方法。以便于接受其他客户端的链接。


第二部分第二小节:


channel.read方法读取客户端传递过来的数据,而且在内部还有一个channel.write方法,表示返回给客户端的信息。代码逻辑是一样的。


第二部分第三小节:


在这里表示读取信息失败,内部也有一个failed方法表示的就是写入信息失败。


第三部分:


这也是一个failed方法,表示的是链接客户端失败。


到这里我们会看到,AIO的代码逻辑很复杂,在这里只是实现一个最简单的通信例子就这么麻烦,稍微增加点功能代码逻辑会让我们发疯。不过为了保持代码的完整性,我们还是要给出客户端的实现。


2、客户端


客户端的实现就比较简单了。


第一步:创建客户端入口类


class AioClient{
    public static void main(String[] args){
        new AioClientHandle().start();
        try {
            Thread.sleep(100000000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
     }
}

在这里我们同样使用一个AioClientHandle来处理客户端的代码逻辑,现在我们继续看代码。


第二步:AioClientHandle类实现:


public class AioClientHandle extends Thread implements CompletionHandler<Void, AioClientHandle> {
    private AsynchronousSocketChannel socketChannel;
    public AioClientHandle() {
        try {
            socketChannel = AsynchronousSocketChannel.open();
            System.out.println("客户端初始化成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 8888), this, this);
    }
    @Override
    public void completed(Void result, AioClientHandle attachment) {
        System.out.println("client链接成功");
        String sendMsg = "我是:java的架构师技术栈,服务端你好";
        ByteBuffer writeBuffer = ByteBuffer.allocate(sendMsg.getBytes().length);
        writeBuffer.put(sendMsg.getBytes());
        writeBuffer.flip();
        socketChannel.write(writeBuffer, writeBuffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                if (attachment.hasRemaining()) {
                    socketChannel.write(writeBuffer, attachment, this);
                } else {
                    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                    socketChannel.read(readBuffer, readBuffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer attachment) {
                            readBuffer.flip();
                            byte[] bytes = new byte[readBuffer.remaining()];
                            readBuffer.get(bytes);
                            System.out.println("客户端读取数据:" + new String(bytes));
                        }
                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            try {
                                System.out.println("客户端读取数据失败");
                                socketChannel.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    });
                }
            }
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                try {
                    System.out.println("客户端写数据失败");
                    socketChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    @Override
    public void failed(Throwable exc, AioClientHandle attachment) {
        try {
            System.out.println("客户端出现异常");
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个代码逻辑和服务端的差不多,在这里就不说了。下面我们主要分析一下为什么不用AIO。


三、AIO的缺点


上面BB了这么久就是为了说明为什么不使用他,你千万别急,因为知己知彼才能百战不殆。你只有理解了AIO才能知道工作中应该用什么,


1、实现复杂


上面的代码量你已经看到了,恶心到不能恶心。实现这么一个简单的功能就要写这么多。


2、需要额外的技能


也就是说你想要学号AIO,还需要java多线程的技术做铺垫才可以。否则我们很难写出质量高的代码。


3、一个著名的Selector空轮询bug


它会导致CPU100%,之前在我的群里面,有人曾经遇到过这个问题,而且官方说在1.6的版本中解决,但是现在还有。遇到的时候我们虽然可以解决但是不知道的人会很痛苦。


4、可靠性差


也就是说我们的网络状态是复杂多样的,会遇到各种各样的问题,比如说网断重连、缓存失效、半包读写等等。可靠性比较差。稍微出现一个问题,还需要大量的代码去完善。


当然还有很多其他的缺点,不过就单单第一条估计就很难发展。后来出现了更加牛的网络通信框架netty。很好的解决了上面的问题,也是目前最主流的框架。更多内容,在后续文章中推出。今天的文章先到这,感谢支持。


目录
打赏
0
0
0
0
26
分享
相关文章
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
160 96
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
一文搞懂NIO、AIO、BIO的核心区别(建议收藏)
本文详细解析了NIO、AIO、BIO的核心区别,NIO的三个核心概念,以及NIO在Java框架中的应用等。关注【mikechen的互联网架构】,10年+BAT架构经验倾囊相授。
一文搞懂NIO、AIO、BIO的核心区别(建议收藏)
JAVA网络IO之NIO/BIO
本文介绍了Java网络编程的基础与历史演进,重点阐述了IO和Socket的概念。Java的IO分为设备和接口两部分,通过流、字节、字符等方式实现与外部的交互。
|
2月前
|
探索Java NIO:究竟在哪些领域能大显身手?揭秘原理、应用场景与官方示例代码
Java NIO(New IO)自Java SE 1.4引入,提供比传统IO更高效、灵活的操作,支持非阻塞IO和选择器特性,适用于高并发、高吞吐量场景。NIO的核心概念包括通道(Channel)、缓冲区(Buffer)和选择器(Selector),能实现多路复用和异步操作。其应用场景涵盖网络通信、文件操作、进程间通信及数据库操作等。NIO的优势在于提高并发性和性能,简化编程;但学习成本较高,且与传统IO存在不兼容性。尽管如此,NIO在构建高性能框架如Netty、Mina和Jetty中仍广泛应用。
59 3
|
2月前
|
Java的NIO体系
通过本文的介绍,希望您能够深入理解Java NIO体系的核心组件、工作原理及其在高性能应用中的实际应用,并能够在实际开发中灵活运用这些知识,构建高效的Java应用程序。
68 5
|
3月前
|
BIO、NIO、AIO 有什么区别
BIO(阻塞I/O)模型中,服务器实现模式为一个连接一个线程;NIO(非阻塞I/O)使用单线程或少量线程处理多个请求;AIO(异步I/O)则是在NIO基础上进一步优化,采用事件通知机制,提高并发处理能力。
111 6
BIO、NIO、AIO在不同场景下的应用对比
BIO(阻塞I/O)、NIO(非阻塞I/O)和AIO(异步I/O)是Java中处理I/O操作的三种模式。BIO适用于连接数少且稳定的场景;NIO通过非阻塞模式提高并发处理能力,适合高并发场景;AIO则完全异步,适合需要高效、低延迟的I/O操作场景。
282 4
java nio,netty,kafka 中经常提到“零拷贝”到底是什么?
零拷贝技术 Zero-Copy 是指计算机执行操作时,可以直接从源(如文件或网络套接字)将数据传输到目标缓冲区, 而不需要 CPU 先将数据从某处内存复制到另一个特定区域,从而减少上下文切换以及 CPU 的拷贝时间。
java nio,netty,kafka 中经常提到“零拷贝”到底是什么?
如何查看已安装的 Java 版本
要查看已安装的 Java 版本,打开命令提示符或终端,输入 `java -version`,回车后即可显示当前系统中 Java 的版本信息。
1388 1
如何检查 Java 版本是否兼容
要检查Java版本是否兼容,可在命令行输入“java -version”查看当前安装的Java版本,然后对比目标应用所需的Java版本,确保其满足要求。
148 1

热门文章

最新文章