Java AIO知识总结

最新推荐文章于 2024-05-23 17:09:10 发布
最新推荐文章于 2024-05-23 17:09:10 发布
阅读量1.2k 收藏 16
点赞数
分类专栏： Java 文章标签： aio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D578332749/article/details/100659494
版权

文章目录

概述

什么是AIO？

Java 1.7升级了NIO类库，升级后的NIO类库被称为NIO 2.0，在NIO2.0中Java提供了异步文件I/O操作，同时提供了与UNIX网络编程事件驱动I/O对应的AIO（Asynchronous I/O），AIO是真正的异步非阻塞I/O，它不需要通过多路复用器（Selector）对注册的通道进行轮询操作即可实现异步读写，从而简化了NIO的编程模型。

AIO与NIO有什么区别？

  1. 按照UNIX网络编程模型区分，NIO是同步非阻塞I/O，AIO是异步非阻塞I/O；
  2. AIO与NIO的操作结果获取方式不同，NIO的操作结束后会将操作就绪的I/O放在队列中，由Selector依次循环获取处理；AIO操作结束后则会直接回调CompletionHandler的实现类的相应函数来进行处理；
  3. 处理操作结果时NIO是单线程，即由Selector依次在当前线程中进行处理，如果需要多线程处理需要自行实现，这也是为什么它是同步而非异步；而AIO在回调处理操作结果时，是多线程的，其底层设有线程池。

AIO性能比NIO更好吗？

目前的AIO与NIO底层都使用了epoll（Linux中），所以二者性能都很好，主要差异在于同步与异步，NIO是同步的，始终只有一个线程在进行结果处理，而AIO的异步回调则是基于多线程的，如果NIO结果处理中引入多线程，个人认为二者性能是相仿的。

什么是epoll？

epoll是Linux中多路复用IO接口select/poll的增强版本，select/poll模型是忙轮询，即一直不停地轮询看哪些操作已经结束可以获取操作结果了，而epoll则是将已经结束的操作的操作结果放入队列中，然后只需要遍历处理队列中的操作就可以了，避免了CPU的浪费，提升程序运行效率。

更详细具体的可以移步百科了解：

https://baike.baidu.com/item/epoll/10738144?fr=aladdin

AIO既然是异步的，那么如何获得操作结果？

AIO中提供了两种方式获取操作结果：

  1. 通过java.util.concurrent.Future类来表示异步操作的结果；
  2. 在执行异步操作时传入一个java.nio.channel，并传入CompletionHandler接口的实现类作为操作完成的回调，CompletionHandler顾名思义就是专门用来处理完成结果的。

Java AIO的API使用

了解CompletionHandler接口

CompletionHandler源码

package java.nio.channels;

/**
 * A handler for consuming the result of an asynchronous I/O operation.
 *
 * <p> The asynchronous channels defined in this package allow a completion
 * handler to be specified to consume the result of an asynchronous operation.
 * The {@link #completed completed} method is invoked when the I/O operation
 * completes successfully. The {@link #failed failed} method is invoked if the
 * I/O operations fails. The implementations of these methods should complete
 * in a timely manner so as to avoid keeping the invoking thread from dispatching
 * to other completion handlers.
 *
 * @param   <V>     The result type of the I/O operation
 * @param   <A>     The type of the object attached to the I/O operation
 *
 * @since 1.7
 */

public interface CompletionHandler<V,A> {

    /**
     * Invoked when an operation has completed.
     *
     * @param   result
     *          The result of the I/O operation.
     * @param   attachment
     *          The object attached to the I/O operation when it was initiated.
     */
    void completed(V result, A attachment);

    /**
     * Invoked when an operation fails.
     *
     * @param   exc
     *          The exception to indicate why the I/O operation failed
     * @param   attachment
     *          The object attached to the I/O operation when it was initiated.
     */
    void failed(Throwable exc, A attachment);
}

解析

CompletionHandler接口中有两个方法需要实现，分别是completed和failed，当操作完成时，会回调completed，出现异常失败时会回调failed。

completed

操作完成时，回调completed函数，其有result和attachment两个参数：

  • result是操作完成后的操作结果；
  • attachment是在进行回调时可以传入的附件，用于回调内的操作；
failed

操作异常时回调failed函数，其有exc和attachment两个参数：

  • exc即进行操作时出现的异常；
  • attachment和completed中的一致，为在进行回调时传入的附件，用于回调内操作；

Demo

    /**
     * 接收请求的结束动作处理类，当异步socket服务接收到一个请求时，会回调此handler，从而对收到的请求进行处理
     */
    private class AcceptCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, SimpleTimeServer> {

        @Override
        public void completed(AsynchronousSocketChannel channel, SimpleTimeServer attachment) {
            ...
        }

        @Override
        public void failed(Throwable exc, SimpleTimeServer attachment) {
            exc.printStackTrace();
            ...
        }
    }

基于AIO的简单时间服务

Server端实现代码

package com.dongrui.study.ioserver.aioserver;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;

/**
 * 使用AIO实现的简单时间服务
 */
public class SimpleTimeServer implements Runnable {
    /**
     * 维持服务线程的门闩
     */
    private CountDownLatch latch;
    /**
     * 异步socket服务通道
     */
    private AsynchronousServerSocketChannel asynchronousServerSocketChannel;

    private SimpleTimeServer(int port) throws IOException {
        //开启异步socket服务
        asynchronousServerSocketChannel = AsynchronousServerSocketChannel.open();
        //绑定端口
        asynchronousServerSocketChannel.bind(new InetSocketAddress(port));
        System.out.println("simple time server start in " + port);
    }


    @Override
    public void run() {
        latch = new CountDownLatch(1);
        //异步socket服务接收请求
        System.out.println("我是监听线程：" + Thread.currentThread());
        asynchronousServerSocketChannel.accept(this, new AcceptCompletionHandler());
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 接收请求的结束动作处理类，当异步socket服务接收到一个请求时，会回调此handler，从而对收到的请求进行处理
     */
    private class AcceptCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, SimpleTimeServer> {

        @Override
        public void completed(AsynchronousSocketChannel channel, SimpleTimeServer attachment) {
            try {
                System.out.println("我是处理线程：" + Thread.currentThread());
                //循环监听，进行监听操作的是SimpleTimeServer运行的线程
                attachment.asynchronousServerSocketChannel.accept(attachment, this);
                //这里休眠20秒，可以看到当处理线程没有处理完成时，会启用新的线程来处理后面的请求
                Thread.sleep(20);
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                //从请求通道中读取数据
                channel.read(buffer, buffer, new ReadCompletionHandler(channel));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void failed(Throwable exc, SimpleTimeServer attachment) {
            //接收请求失败，打印异常信息，将门闩减一，服务线程终止
            exc.printStackTrace();
            attachment.latch.countDown();
        }
    }

    /**
     * 读取数据的结束动作处理类，当系统将数据读取到buffer中，会回调此handler
     */
    private class ReadCompletionHandler implements CompletionHandler<Integer, ByteBuffer> {

        private AsynchronousSocketChannel channel;

        ReadCompletionHandler(AsynchronousSocketChannel channel) {
            this.channel = channel;
        }

        @Override
        public void completed(Integer byteNum, ByteBuffer readBuffer) {
            if (byteNum <= 0)
                return;
            readBuffer.flip();
            byte[] body = new byte[byteNum];
            readBuffer.get(body);
            String req = new String(body, StandardCharsets.UTF_8);
            System.out.println("the time server received order: " + req);
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String currentTime = "query time order".equalsIgnoreCase(req) ? format.format(new Date()) + "" : "bad order";
            doWrite(currentTime);
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            try {
                //读取失败，关闭通道
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        private void doWrite(String msg) {
            if (null != msg) {
                byte[] bytes = msg.getBytes(StandardCharsets.UTF_8);
                ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
                writeBuffer.put(bytes);
                writeBuffer.flip();
                channel.write(writeBuffer, writeBuffer,
                        //写操作结束的回调handler
                        new CompletionHandler<Integer, ByteBuffer>() {
                            @Override
                            public void completed(Integer result, ByteBuffer buffer) {
                                if (buffer.hasRemaining()) {
                                    channel.write(buffer, buffer, this);
                                }
                            }

                            @Override
                            public void failed(Throwable exc, ByteBuffer attachment) {
                                try {
                                    channel.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        });
            }
        }
    }

    public static void main(String[] args) {
        try {
            System.out.println("我是主线程：" + Thread.currentThread());
            new SimpleTimeServer(8088).run();
            System.out.println("监听线程已挂");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Client端实现代码

package com.dongrui.study.ioclient.aioclient;

import com.google.common.primitives.Bytes;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.channels.InterruptedByTimeoutException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * 基于AIO的简单时间服务客户端
 */
public class SimpleTimeClient {

    private String host;
    private int port;
    private CountDownLatch latch;

    /**
     * 异步socket通道
     */
    private AsynchronousSocketChannel channel;

    private SimpleTimeClient(String host, int port) throws IOException {
        this.host = host;
        this.port = port;
        this.latch = new CountDownLatch(1);
        initChannel();
    }

    private void initChannel() throws IOException {
        // 打开异步socket通道
        channel = AsynchronousSocketChannel.open();
        // 异步连接指定地址，连接完成后会回调ConnectionCompletionHandler
        channel.connect(new InetSocketAddress(host, port), null, new ConnectionCompletionHandler());
    }

    private class ConnectionCompletionHandler implements CompletionHandler<Void, Void> {

        @Override
        public void completed(Void result, Void attachment) {
            System.out.println("connection thread: " + Thread.currentThread());
            String msg = "query time order";
            ByteBuffer writeBuffer = ByteBuffer.allocate(msg.length());
            writeBuffer.put(msg.getBytes(StandardCharsets.UTF_8)).flip();
            // 异步写入发送数据，写入完成后会回调WriteCompletionHandler
            channel.write(writeBuffer, null, new WriteCompletionHandler());
        }

        @Override
        public void failed(Throwable exc, Void attachment) {
            exc.printStackTrace();
            latch.countDown();
        }
    }

    /**
     * 读取到的byte集合和缓存
     */
    private class BufferAndArr {
        public BufferAndArr(List<Byte> bytesArr, ByteBuffer buffer) {
            this.bytesArr = bytesArr;
            this.buffer = buffer;
        }

        List<Byte> bytesArr;
        ByteBuffer buffer;
    }

    /**
     * 写数据完成回调处理类
     */
    private class WriteCompletionHandler implements CompletionHandler<Integer, Void> {

        @Override
        public void completed(Integer result, Void attachment) {
            System.out.println("write thread: " + Thread.currentThread());
            List<Byte> rtnBytesArr = new ArrayList<>();
            ByteBuffer readBuffer = ByteBuffer.allocate(1024);
            // 异步读取返回的数据，读取结束后会回调ReadCompletionHandler
            channel.read(readBuffer, 1000, TimeUnit.MILLISECONDS, new BufferAndArr(rtnBytesArr, readBuffer), new ReadCompletionHandler());
        }

        @Override
        public void failed(Throwable exc, Void attachment) {
            exc.printStackTrace();
            latch.countDown();
        }
    }

    /**
     * 读数据完成回调处理类
     */
    private class ReadCompletionHandler implements CompletionHandler<Integer, BufferAndArr> {
        @Override
        public void completed(Integer bytesNum, BufferAndArr attachment) {
            System.out.println("read thread: " + Thread.currentThread());
            int size = attachment.buffer.limit();
            attachment.buffer.flip();
            byte[] tempBytes = new byte[bytesNum];
            attachment.buffer.get(tempBytes);
            attachment.bytesArr.addAll(Bytes.asList(tempBytes));
            // 根据读取到的数据长度与缓存总长度比较，相等则继续读取，否则读取结束
            if (bytesNum >= size) {
                attachment.buffer.clear();
                // 继续读取时加入超时时间，如果已经读取完，则会触发超时异常，转到fail中
                channel.read(attachment.buffer, 1000, TimeUnit.MILLISECONDS, attachment, new ReadCompletionHandler());
            } else {
                completionAction(attachment.bytesArr);
            }
        }

        @Override
        public void failed(Throwable exc, BufferAndArr attachment) {
            // 当没有数据时会超时抛出InterruptedByTimeoutException异常，然后在这里处理读取结果，因为暂时没有发现更好的方法
            if (exc instanceof InterruptedByTimeoutException) {
                completionAction(attachment.bytesArr);
            } else {
                exc.printStackTrace();
            }
        }

        private void completionAction(List<Byte> bytesArr) {
            System.out.println("当前时间：" + new String(Bytes.toArray(bytesArr), StandardCharsets.UTF_8));
            latch.countDown();
        }
    }

    public static void main(String[] args) {
        while (true) {
            new Thread(() -> {
                try {
                    System.out.println("time client thread: " + Thread.currentThread());
                    SimpleTimeClient client = new SimpleTimeClient("localhost", 8088);
                    client.latch.await();
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
imdongrui
关注
  • 0
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java AIO
JustinMars的博客
08-04 486
Java AIO
Java SE知识点总结
子衿
09-15 489
1.Java-内存管理（字符集与编码） 2.Java-类、接口 3.Java-内部类、权限修饰符 4.Java-比较运算符、equal、迭代器、增强for循环 5.Java-泛型、可变参数 6.Java中List、Set、Map集合以及Collection集合工具类 7.Java-多态 8.Java-异常处理 9.Java-多线程 10.Java-Lambda表达式 11.Ja...
Java网络编程IO模型 --- BIO、NIO、AIO详解
wanghuichen的博客
02-15 2976
通俗易懂详解 -- Java网络编程IO模型 BIO、NIO、AIO
Java 网络编程模型(新)AIO原理
最新发布
jiaoyaqiang的博客
05-23 873
和多路复用的Java NIO相比较，可以发现，异步IO是在数据读取或者写入调用已经完成的时候，再通知调用者，而非阻塞多路复用IO则是在有数据就绪，可以读写的时候通知调用者，读写仍然是由调用者执行，并且是阻塞的（这意味着如果要同时进行其他工作，要控制读写操作不能阻塞太长时间或者需要将其放去单独的IO线程执行)。因为AIO的实现需要充分调用OS，IO需要操作系统支持、并发也同样需要操作系统的支持，所以性能方面不同操作系统差异会比较明显。除了CompletionHandler。目前为止，Java共支持3种。
java中IO模型-AIO模型
m0_46853673的博客
10-02 3025
AIO模型介绍 AIO（Asynchronous I/O） 异步非阻塞模型， 在javajdk.17版本开始支持AIO，AIO模型需要操作系统的支持。 AIO最大的特性是异步能力，对socket和I/O起作用。 异步IO模型类似的 与NIO模型不同，读写操作为例，只需直接调用read和write的API即可，这方法都是异步的。 对于读操作:当有流可读是，系统会将可读的流传入到read方法的缓冲区，并通知应用程序。 读写都是异步的，完成之后会主动调用回调函数。 在JDK 1.7中，nio.2,主要在java
深入分析 Java IO （四）AIO
码灵的博客
06-15 544
前面我们对Java IOBIONIO进行了分析，本篇文章我们就来讲讲AIO的相关知识。从Java 1.7开始，Java 提供了AIO（异步I/O）。Java AIO 也被称为NIO2.0，提供了异步I/O的方式，用法和标准的I/O有非常大的差异。Java AIO 采用订阅-通知即应用程序向操作系统注册IO监听，然后继续做自己的事情。当操作系统发生IO事件，并且准备好数据后，在主动通知应用程序，触发相应的函数。Java BIO。
通俗易懂的JAVA BIO NIO AIO 原理白话文解释，区别，优缺点及代码使用案例
峡谷电光马仔的博客
10-28 1973
通俗易懂的JAVA BIO NIO AIO 原理白话文解释，区别，优缺点及代码使用案例 BIO 介绍与原理 场景描述 优点 缺点 ，BIO 代码示例 NIO 介绍与原理 场景描述 优点 缺点 ，NIO 代码示例 AIO 介绍与原理 场景描述 优点 缺点 ，AIO 代码示例
到底什么是Java AIO？为什么Netty会移除AOI？一文搞懂AIO的本质！
hellojackjiang2011的博客
06-21 1075
Java AIO的这些不合常理的现象难免会令人心存疑惑。所以决定写这篇文章时，我不想只是简单的把AIO的概念再复述一遍，而是要透过现象，深入分析、思考和并理解Java AIO的本质。
JavaIO流知识点总结
ojemmm的博客
10-14 1630
知识点 package IO流原理与概念; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; import...
JAVA体系总结内容.doc
12-21
1. **基础知识**：这是学习JAVA的第一步，包括基础语法，如数据类型、控制结构、方法等。面向对象是JAVA的核心，包括类、对象、封装、继承和多态。集合框架（如ArrayList、LinkedList、HashMap等）和类库API（如Math...
java IO NIO AIO.xmind
05-11
涉及到java io, nio, aio相关知识点，学习过程中的一些总结，持续更新中，xmind 格式
Java基础总结下1
08-04
本文将对Java基础知识进行详尽的总结，涵盖从Java版本、IO模型到集合框架，以及并发编程等多个重要知识点。 首先，Java自发布以来已经经历了多个版本的迭代，Java 2.0是一个重要的里程碑，它引入了许多新特性，例如...
java学习资料总结
07-02
Java学习资料总结主要聚焦在Java多线程领域，是一份深度探索Java并发编程的资源集合。这份资料旨在帮助初学者和有一定经验的开发者系统性地理解并掌握Java中的多线程概念和技术，提升并发编程能力。 首先，"前言...
Java核心知识点记录学习
06-22
本文将深入探讨Java的核心知识点，包括基础语法、虚拟机（JVM）、数据库交互、计算机网络、算法运用、操作系统理解、设计模式实践以及框架原理。 1. **Java基础**：Java的基础语法包括变量、数据类型、控制结构（如...
java基础--AIO
weixin_50204197的博客
02-01 397
java基础，AIO，同步，异步，阻塞，非阻塞
透过现象看Java AIO的本质
crg18438610577的博客
03-31 747
透过现象看Java AIO的本质 ～～～
java aio_【Java】Java AIO使用
weixin_32973973的博客
02-12 336
欢迎关注公众号: nullobject 。文章首发在个人博客 https://www.nullobject.cn，公众号nullobject同步更新。这篇文章主要介绍Java AIO网络编程。1. AIO是什么本文所说的AIO特指Java环境下的AIO。AIO是java中IO模型的一种，作为NIO的改进和增强随JDK1.7版本更新被集成在JDK的nio包中，因此AIO也被称作是NIO2.0。区别于...
Java I/O大揭秘：BIO、NIO、AIO到底有何区别？
孤芳不自赏
06-22 554
这篇文章你值得一阅！讲技术我觉得应该让外行也能看明白，而不是一堆专业术语堆砌，像在读天书一般，到最后感觉云里雾里。
Java基础BIO、NIO、AIO小结
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
10-25 866
BIO通信过程如下图所示，可以看到客户端成功与服务端建立连接后会因为等待服务端处理并响应结果而需要进行阻塞。而服务端在没有客户端发起请求时也会进入循环阻塞。并且服务端必须只有处理完这个请求后，才会去处理其他用户的请求。所以在高并发场景下，无论用户体验，还是服务器处理效率和压力都是灾难性的打击。
java aio框架
07-29
Java AIO（Asynchronous I/O）框架是一个基于Java NIO（Non-blocking I/O）的异步I/O框架。它提供了一种非阻塞的I/O模型，使得可以在一个线程中处理多个I/O操作。Java AIO框架在Java 7中引入，并且在Java 11之后成为了标准的Java API。 使用Java AIO框架，可以使用异步的方式处理I/O操作，而不需要像传统的同步I/O模型那样阻塞线程等待I/O完成。这样可以提高系统的吞吐量和并发性能。 Java AIO框架主要使用两个关键组件：CompletionHandler和AsynchronousChannel。CompletionHandler用于处理异步操作的结果，而AsynchronousChannel则是进行I/O操作的通道。 通过使用Java AIO框架，可以实现诸如异步读写文件、异步网络通信等功能。它适用于需要处理大量并发I/O操作的场景，例如高并发的服务器应用程序。 需要注意的是，Java AIO框架在实现上相对复杂，使用起来相对较难。但是，它能够提供更好的性能和可伸缩性，特别适用于高并发和高吞吐量的应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值