08【AIO编程】

最新推荐文章于 2024-08-29 19:12:03 发布
最新推荐文章于 2024-08-29 19:12:03 发布
阅读量719 收藏 3
点赞数 1
分类专栏： # 《Java IO模型系列》 文章标签： java 网络 NIO AIO 异步
緑水長流原创出品，未经许可禁止转载！
本文链接：https://blog.csdn.net/Bb15070047748/article/details/125952458
版权

八、AIO编程

8.1 AIO编程简介

8.1.1 AIO编程概述

AIO也叫异步非阻塞，JDK1.7之后的新特性，AIO引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

与NIO模型不同，读写操作为例，只需直接调用read和write的API即可，这方法都是异步的对于读操作，当有流可读时，系统会将可读的流传入到read方法的缓冲区，并通知应用程序读写都是异步的，完成之后会主动调用回调函数；

AIO需要操作系统的支持，在Linux内核2.6版本之后增加了对真正异步IO的实现。Java从JDK1.7之后支持AIO，JDK1.7新增一些与文件/网络IO相关的一些API，称之为NIO2.0或者称之为AIO（Asynchronous IO）。AIO最大的特征提供了异步功能，对于socket网络通信和文件IO都是起作用的。

8.1.2 AIO与其他IO的区别

AIO是异步非阻塞IO，AIO实现了真正意义上的异步处理。

  • 异步：当在处理一个请求的同时，还可以同时处理其他请求，并且当请求处理完毕时（开始响应数据），基于事件回调的方式将数据响应给调用者，调用者不需要再次来到提供者这边读取数据，而是直接读取调用者中用户空间中的数据，完完全全的做到了异步处理；
  • 非阻塞：在AIO中，调用任何的请求连接、读取提供者数据等方法都不会造成当前线程阻塞，而是将请求告诉给了服务提供者，自己可以去处理其他任务；服务提供者接收到请求后，实现自身的业务逻辑处理，然后将数据数据发送给调用者；

BIO（同步阻塞）：

在这里插入图片描述

NIO（同步非阻塞）：

在这里插入图片描述

AIO（同步非阻塞）：

在这里插入图片描述

  • BIO同步阻塞：到理发店理发，理发店人多，就一直等理发师，知道轮到自己理发

  • NIO同步非阻塞：到理发店理发，发现理发店人很多，就先告诉理发师说一会再来，自己先去干其它事情，一会再回来看看是否轮到了自己

  • AIO异步非阻塞：给理发师打电话，让理发师上门服务，自己干其它事情，理发师自己来家里理发

8.2 实现AIO编程

在Java中，实现AIO编程的主要有AsynchronousFileChannel、AsynchronousServerSocketChannel、AsynchronousSocketChannel等三个异步通道类；使用read、accept等阻塞方法时，异步通道则是基于事件回调的方式来处理阻塞问题；

即：当调用阻塞方法时不再阻塞当前线程，并且当数据提供者响应数据时将，数据请求方将会自动将操作系统内核所获取到的数据复制到用户空间，供用户提供者使用；

8.2.1 AIO基于文件编程

1）基于Future-读
  • 示例代码：
package com.aio.demo01_asynchronousFileChannel;

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_通过Future读取数据 {
    public static void main(String[] args) throws Exception {

        Path path = Paths.get("001.txt");

        // 创建一个异步的FileChannel对象,设置为读模式
        AsynchronousFileChannel fileChannel =
                AsynchronousFileChannel.open(path, StandardOpenOption.READ);

        // 创建Buffer来接收AsynchronousFileChannel的数据
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 进行异步读取
        Future<Integer> future = fileChannel.read(buffer, 0);

        /*
         如果isDone()返回true,代表内核空间已经准备好了数据,并且已经将内核的数据拷贝到用户空间了
         返回false,则代表内核空间暂时没有数据,或者数据还没有从内核拷贝到用户空间
         */
        while (!future.isDone()) ;

        // limit=position,position=0
        buffer.flip();

        System.out.println(new String(buffer.array()));

        // position=0,limit=capacity
        buffer.clear();

        // 可以获取到读取的字节数
        Integer count = future.get();
        System.out.println("读取完毕,共读取到【" + count + "】个字节");
    }
}
2）基于CompletionHandler-读
  • 示例代码：
package com.aio.demo01_asynchronousFileChannel;

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_通过CompletionHandler读取数据 {
    public static void main(String[] args) throws Exception {

        Path path = Paths.get("001.txt");

        // 创建一个异步的FileChannel对象,设置为读模式
        AsynchronousFileChannel fileChannel =
                AsynchronousFileChannel.open(path, StandardOpenOption.READ);

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        // 进行异步读取
        fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            /**
             * 读取完毕时调用的方法
             * @param result: 读取的字节数量
             * @param attachment: 附着的信息,该参数等于fileChannel调用read时传递的buffer(第三个参数的buffer)
             */
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                // true
                System.out.println(buffer == attachment);

                // limit=position,position=0
                buffer.flip();

                System.out.println(new String(buffer.array()));

                // position=0,limit=capacity
                buffer.clear();
            }

            /**
             * 读取失败时调用的方法
             * @param exc: 出现的异常
             * @param attachment: 外面传递的那个buffer对象
             */
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                exc.printStackTrace();
            }
        });

        System.out.println("程序执行完毕...");
    }
}
3）基于Future-写
  • 示例代码：
package com.aio.demo01_asynchronousFileChannel;

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_通过Future写取数据 {
    public static void main(String[] args) throws Exception {

        Path path = Paths.get("001.txt");

        // 创建一个AsynchronousFileChannel,对与该类来说,每次运行不会清空文件,而是每次运行都会把本次的内容覆盖文件之前的内容
        AsynchronousFileChannel fileChannel =
                AsynchronousFileChannel.open(
                        path,
                        StandardOpenOption.WRITE,
                        StandardOpenOption.TRUNCATE_EXISTING       // 如果文件里面有内容那么就清空数据
                );

        ByteBuffer buffer = ByteBuffer.wrap("abc".getBytes());

        Future<Integer> future = fileChannel.write(buffer, 0);

        System.out.println("写出【" + future.get() + "】个字节");

        fileChannel.close();
    }
}
4）基于CompletionHandler-写
  • 示例代码：
package com.aio.demo01_asynchronousFileChannel;

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04_通过CompletionHandler写取数据 {
    public static void main(String[] args) throws Exception {

        Path path = Paths.get("001.txt");

        // 创建一个AsynchronousFileChannel,对与该类来说,每次运行不会清空文件,而是每次运行都会把本次的内容覆盖文件之前的内容
        AsynchronousFileChannel fileChannel =
                AsynchronousFileChannel.open(
                        path,
                        StandardOpenOption.WRITE,
                        StandardOpenOption.TRUNCATE_EXISTING            // 如果文件里面有内容那么就清空数据
                );

        ByteBuffer buffer = ByteBuffer.wrap("abc".getBytes());

        fileChannel.write(buffer, 0, null, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                System.out.println("写出【" + result + "】个字节");
            }

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

        System.out.println("写入完毕....");

        // 让程序不要这么快结束(等待completed回调函数执行)
        Thread.sleep(100);
    }
}

8.2.2 AIO基于网络编程

1）服务端
  • 示例代码：
package com.aio.demo01_asynchronousFileChannel;

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;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05_基于服务器的AIO通信模式_服务端 {
    public static void main(String[] args) throws Exception {

        // 创建一个异步的ServerSocketChannel
        AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open();

        // 绑定IP和端口
        serverSocketChannel.bind(new InetSocketAddress("127.0.0.1", 8888));

        /*
         接收一个客户端
            该方法不会阻塞当前线程,而是基于事件回调的形式,当接收到客户端时执行回调函数把接收到的客户端传递进去
         */
        serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            /**
             * 接收成功执行的回调
             * @param socketChannel: 客户的Channel
             * @param attachment: 添加的附着信息
             */
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {

                ByteBuffer buffer = ByteBuffer.allocate(1024);

                    /*
                    使用AsynchronousSocketChannel进行读取
                        该方法并不会阻塞当前线程,而是基于事件回调的形式,当客户端有数据可读时,触发回调函数
                    */
                socketChannel.read(buffer, null, new CompletionHandler<>() {
                    @Override
                    public void completed(Integer result, Object attachment) {
                        // limit=position,position=0
                        buffer.flip();

                        try {
                            System.out.println("接收到了来自客户端【" + socketChannel.getRemoteAddress() + "】发送的信息: " + new String(buffer.array()));
                        } catch (IOException exception) {
                            exception.printStackTrace();
                        }

                        // position=0,limit=capacity
                        buffer.clear();
                    }

                    @Override
                    public void failed(Throwable exc, Object attachment) {

                    }
                });

            }

            /**
             * 接收失败的回调
             * @param exc
             * @param attachment
             */
            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });

        // 让程序不会结束
        System.in.read();
    }
}
2）客户端
  • 示例代码：
package com.aio.demo01_asynchronousFileChannel;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo06_基于服务器的AIO通信模式_客户端 {
    public static void main(String[] args) throws Exception {

        // 获取一个异步的SocketChannel
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();

        /*
         连接到服务器
            该方法不会阻塞,
         */
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 8888), null, new CompletionHandler<Void, Object>() {

            /**
             * 连接服务器成功执行的方法
             * @param result
             * @param attachment
             */
            @Override
            public void completed(Void result, Object attachment) {

                ByteBuffer buffer = ByteBuffer.allocate(1024);

                buffer.put("hello".getBytes());
                // limit=position,position=0
                buffer.flip();

                // 将数据发送到服务器
                socketChannel.write(buffer);

                // position=0,limit=capacity
                buffer.clear();
            }


            @Override
            public void failed(Throwable exc, Object attachment) {

            }
        });

        // 让程序不会结束
        System.in.read();
    }
}
緑水長流*z
关注
专栏目录
NIO，AIO编程视频3
10-16
AIO，NIO编程视频
Netty学习——基础篇3（AIO编程）
geminigoth的博客
02-28 1009
NIO 2.0 引入了新的异步通道概念，并提供了异步文件通道和异步套接字通道的实现。异步通道提供以下两种方式获取操作结果。1、通过java.util.concurrent.Future类来表示异步操作的结果；2、在执行异步操作的时候传入一个java.nio.channelsCompletionHandler接口的实现类作为操作完成的回调。NIO2.0 的异步套接字通道是真正的异步非阻塞的时间驱动I/O(AIO)。
Java新一代网络编程模型AIO原理及Linux系统AIO介绍
You can walk as far as you want.
05-30 383
从JDK 7版本开始，Java新加入的文件和网络io特性称为nio2(new io 2, 因为jdk1.4中已经有过一个nio了)，包含了众多性能和功能上的改进，其中最重要的部分，就是对异步io的支持，称为Java AIO(asynchronous IO)。因为AIO的实施需充分调用OS参与，IO需要操作系统支持、并发也同样需要操作系统的支持，所以性能方面不同操作系统差异会比较明显。所以本文也附带介绍了Linux 2.6及以后版本新增的AIO特性（因为这跟Java AIO是对应关系）。
Java NIO学习篇之StandardOpenOption详解
qq_40837310的博客
05-21 5664
定义： StandardOpenOption是一个枚举类，代表着文件连接时的标准选项。通常可以多个选项一起使用。 public enum StandardOpenOption implements OpenOption { /** * 以读的方式连接文件。 */ READ, /** * 以写的方式连接文件。 */ WRITE, /** * 以追加的方式连接文件，不会覆盖文件原本内容，在后面追加。 */
一文说清楚NIO和AIO+图文解说+Java代码演示
怀揣梦想，一颗执着于技术的心从未磨灭，内心住着一颗顽强的小强时刻提醒自己层层突破自我，同时也成就他人
02-09 1334
NIO是New I/O的简称，与旧式的基于流的I/O方法相对，从名字看，它表示新的一套Java I/O标准。NIO是基于块（Block）的，它以块为基本单位处理数据为所有的原始类型提供（Buffer）缓存支持增加通道（Channel）对象，作为新的原始 I/O 抽象支持锁和内存映射文件的文件访问接口提供了基于Selector的异步网络I/O。
Java NIO&AIO
www_tlj的专栏
05-11 992
Java NIO（New Input/Output）和 AIO（Asynchronous Input/Output）都是Java平台上处理非阻塞I/O的技术，但它们在处理I/O操作的方式和实现机制上有着显著的差异。
NIO，AIO编程视频2
10-16
NIO，AIO编程
NIO，AIO编程视频5
10-16
AIO、NIO编程视频
NIO，AIO编程视频4
10-16
AIO、NIO编程视频
AIO异步网络编程模型-TIO.md
08-18
tio源码分析socket服务启动，接收消息流程。适合人群高级开发软件工程师
JAVA 7 AIO 学习笔记
01-22
JAVA 7 AIO 学习笔记，很详细的讲解
Java网络编程IO模型 --- BIO、NIO、AIO详解
wanghuichen的博客
02-15 3420
通俗易懂详解 -- Java网络编程IO模型 BIO、NIO、AIO
AIO基础API应用剖析
qq_40429540的博客
10-23 372
目录
7天掌握NIO和SOCKET，第四天，通道打开文件的StandardOpenOption的枚举常量的使用方法，判断通道是否打开
qq_40666620的博客
05-04 1606
import java.io.File; import java.io.RandomAccessFile; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.channels.FileChannel; import java.nio.charset.Charset; import java.nio.fi...
使用NIO和AIO进行文件读写
fmzone的博客
04-22 1827
NIO:package org.test.file.nio;import java.io.File;import java.io.RandomAccessFile;import java.nio.ByteBuffer;import java.nio.channels.FileChannel;import java.nio.charset.Charset;public class NioTest {...
Java 入门指南：Java NIO —— Channel（通道）
最新发布
Zachyy的博客
08-29 1609
通道（Channel）是 `NIO`（New Input/Output）模型中的一个重要概念。通道代表着与底层 I/O 设备（如文件、网络套接字等）之间的连接，用于将数据传输到缓冲区或从缓冲区传输数据。 Channel 不与数据打交道，它只负责运输数据 通道在 NIO 中起到了桥梁作用，负责将数据从缓冲区传输到通道或者从通道传输到缓冲区。它是一个双向的数据传输通道。
三 小飞鸟——java网络编程
11-15
本课程主讲java网络编程，网络基本知识及应用。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

緑水長流*z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值