BIO、NIO、AIO 模型工作方式

描述

一、简介

在计算机中,IO 传输数据有三种工作方式,分别是: BIO、NIO、AIO

在讲解 BIO、NIO、AIO 之前,我们先来回顾一下这几个概念: 同步与异步,阻塞与非阻塞

同步与异步的区别

  • 同步就是发起一个请求后,接受者未处理完请求之前,不返回结果。
  • 异步就是发起一个请求后,立刻得到接受者的回应表示已接收到请求,但是接受者并没有处理完,接受者通常依靠事件回调等机制来通知请求者其处理结果。

阻塞和非阻塞的区别

  • 阻塞就是请求者发起一个请求,一直等待其请求结果返回,也就是当前线程会被挂起,无法从事其他任务,只有当条件就绪才能继续。
  • 非阻塞就是请求者发起一个请求,不用一直等着结果返回,可以先去干其他事情,当条件就绪的时候,就自动回来。

而我们要讲的 BIO、NIO、AIO 就是同步与异步、阻塞与非阻塞的组合。

  • BIO:同步阻塞 IO;
  • NIO:同步非阻塞 IO;
  • AIO:异步非阻塞 IO;

不同的工作方式,带来的传输效率是不一样的,下面我们以网络 IO 为例,一起看看不同的工作方式下,彼此之间有何不同

二、BIO

BIO 俗称同步阻塞 IO,是一种非常传统的 IO 模型,也是最常用的网络数据传输处理方式,优点就是编程简单,但是缺点也很明显,I/O 传输性能一般比较差,CPU 大部分处于空闲状态。

采用 BIO 通信模型的服务端,通常由一个独立的 Acceptor 线程负责监听所有客户端的连接,当服务端接受到多个客户端的请求时,所有的客户端只能排队等待服务端一个一个的处理。

BIO 通信模型图如下!

网络数据传输

一般在服务端通过while(true)循环中会调用accept()方法监听客户端的连接,一旦接收到一个连接请求,就可以建立通信套接字进行读写操作,此时不能再接收其他客户端连接请求,只能等待同当前连接的客户端的操作执行完成。

服务端操作,样例程序如下

public class BioServerTest {

    public static void main(String[] args) throws IOException {
        //初始化服务端socket并且绑定 8080 端口
        ServerSocket serverSocket = new ServerSocket(8080);
        //循环监听客户端请求
        while (true){
            try {
                //监听客户端请求
                Socket socket = serverSocket.accept();

                //将字节流转化成字符流,读取客户端输入的内容
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                //读取一行数据
                String str = bufferedReader.readLine();
                //打印客户端发送的信息
                System.out.println("服务端收到客户端发送的信息:" + str);

                //向客户端返回信息,将字符转化成字节流,并输出
                PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                printWriter.println("hello,我是服务端,已收到消息");

                // 关闭流
                bufferedReader.close();
                printWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端操作,样例程序如下

public class BioClientTest {

    public static void main(String[] args) {
        //创建10个线程,模拟10个客户端,同时向服务端发送请求
        for (int i = 0; i < 10; i++) {
            final int j = i;//定义变量
            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        //通过IP和端口与服务端建立连接
                        Socket socket =new Socket("127.0.0.1",8080);
                        //将字符流转化成字节流,并输出
                        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                        String str="Hello,我是" + j + "个,客户端!";
                        printWriter.println(str);

                        //从输入流中读取服务端返回的信息,将字节流转化成字符流
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        //读取内容
                        String result = bufferedReader.readLine();
                        //打印服务端返回的信息
                        System.out.println("客户端发送请求内容:" + str + " - > 收到服务端返回的内容:" + result);

                        // 关闭流
                        bufferedReader.close();
                        printWriter.close();
                        // 关闭socket
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

最后,依次启动服务端、客户端,看看控制台输出情况如何。

服务端控制台结果如下:

服务端收到客户端发送的信息:Hello,我是8个,客户端!
服务端收到客户端发送的信息:Hello,我是9个,客户端!
服务端收到客户端发送的信息:Hello,我是7个,客户端!
服务端收到客户端发送的信息:Hello,我是5个,客户端!
服务端收到客户端发送的信息:Hello,我是4个,客户端!
服务端收到客户端发送的信息:Hello,我是3个,客户端!
服务端收到客户端发送的信息:Hello,我是6个,客户端!
服务端收到客户端发送的信息:Hello,我是2个,客户端!
服务端收到客户端发送的信息:Hello,我是1个,客户端!
服务端收到客户端发送的信息:Hello,我是0个,客户端!

客户端控制台结果如下:

客户端发送请求内容:Hello,我是8个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是9个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是7个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是5个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是4个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是3个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是6个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是2个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是1个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息
客户端发送请求内容:Hello,我是0个,客户端! - > 收到服务端返回的内容:hello,我是服务端,已收到消息

随着客户端的请求次数越来越多,可能需要排队的时间会越来越长,因此是否可以在服务端,采用多线程编程进行处理呢?

答案是,可以的!

下面我们对服务端的代码进行改造,服务端多线程操作,样例程序如下:

public class BioServerTest {

    public static void main(String[] args) throws IOException {
        //初始化服务端socket并且绑定 8080 端口
        ServerSocket serverSocket = new ServerSocket(8080);
        //循环监听客户端请求
        while (true){
            //监听客户端请求
            Socket socket = serverSocket.accept();
            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        String threadName = Thread.currentThread().toString();
                        //将字节流转化成字符流,读取客户端输入的内容
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        //读取一行数据
                        String str = bufferedReader.readLine();
                        //打印客户端发送的信息
                        System.out.println("线程名称" + threadName + ",服务端收到客户端发送的信息:" + str);

                        //向客户端返回信息,将字符转化成字节流,并输出
                        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                        printWriter.println("hello,我是服务端,已收到消息");

                        // 关闭流
                        bufferedReader.close();
                        printWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

依次启动服务端、客户端,服务端控制台输出结果如下:

线程名称Thread[Thread-8,5,main],服务端收到客户端发送的信息:Hello,我是4个,客户端!
线程名称Thread[Thread-4,5,main],服务端收到客户端发送的信息:Hello,我是8个,客户端!
线程名称Thread[Thread-0,5,main],服务端收到客户端发送的信息:Hello,我是1个,客户端!
线程名称Thread[Thread-7,5,main],服务端收到客户端发送的信息:Hello,我是5个,客户端!
线程名称Thread[Thread-5,5,main],服务端收到客户端发送的信息:Hello,我是2个,客户端!
线程名称Thread[Thread-9,5,main],服务端收到客户端发送的信息:Hello,我是3个,客户端!
线程名称Thread[Thread-1,5,main],服务端收到客户端发送的信息:Hello,我是0个,客户端!
线程名称Thread[Thread-3,5,main],服务端收到客户端发送的信息:Hello,我是7个,客户端!
线程名称Thread[Thread-2,5,main],服务端收到客户端发送的信息:Hello,我是9个,客户端!
线程名称Thread[Thread-6,5,main],服务端收到客户端发送的信息:Hello,我是6个,客户端!

当服务端接收到客户端的请求时,会给每个客户端创建一个新的线程进行链路处理,处理完成之后,通过输出流返回应答给客户端,最后线程会销毁。

但是这样的编程模型也有很大的弊端,如果出现 100、1000、甚至 10000 个客户端同时请求服务端,采用这种编程模型,服务端也会创建与之相同的线程数量, 线程数急剧膨胀可能会导致线程堆栈溢出、创建新线程失败等问题,最终可能导致服务端宕机或者僵死,不能对外提供服务

三、伪异步 BIO

为了解决上面提到的同步阻塞 I/O 面临的一个链路需要一个线程处理的问题,后来有人对它的编程模型进行了优化。

在服务端通过使用 Java 中ThreadPoolExecutor线程池机制来处理多个客户端的请求接入,防止由于海量并发接入导致资源耗尽,让线程的创建和回收成本相对较低,保证了系统有限的资源得以控制,实现了 N (客户端请求数量)大于 M (服务端处理客户端请求的线程数量)的伪异步 I/O 模型。

伪异步 IO 模型图,如下图:

网络数据传输

采用线程池和任务队列可以实现一种叫做伪异步的 I/O 通信框架,当有新的客户端接入时,将客户端的 Socket 封装成一个 Task 投递到线程池中进行处理。

服务端采用线程池处理客户端请求,样例程序如下:

public class BioServerTest {

    public static void main(String[] args) throws IOException {
        //在线程池中创建5个固定大小线程,来处理客户端的请求
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        //初始化服务端socket并且绑定 8080 端口
        ServerSocket serverSocket = new ServerSocket(8080);
        //循环监听客户端请求
        while (true){
            //监听客户端请求
            Socket socket = serverSocket.accept();
            //使用线程池执行任务
            executorService.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        String threadName = Thread.currentThread().toString();
                        //将字节流转化成字符流,读取客户端输入的内容
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        //读取一行数据
                        String str = bufferedReader.readLine();
                        //打印客户端发送的信息
                        System.out.println("线程名称" + threadName + ",服务端收到客户端发送的信息:" + str);

                        //向客户端返回信息,将字符转化成字节流,并输出
                        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                        printWriter.println("hello,我是服务端,已收到消息");

                        // 关闭流
                        bufferedReader.close();
                        printWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

依次启动服务端、客户端,服务端控制台输出结果如下:

线程名称Thread[pool-1-thread-4,5,main],服务端收到客户端发送的信息:Hello,我是6个,客户端!
线程名称Thread[pool-1-thread-2,5,main],服务端收到客户端发送的信息:Hello,我是8个,客户端!
线程名称Thread[pool-1-thread-3,5,main],服务端收到客户端发送的信息:Hello,我是9个,客户端!
线程名称Thread[pool-1-thread-5,5,main],服务端收到客户端发送的信息:Hello,我是5个,客户端!
线程名称Thread[pool-1-thread-1,5,main],服务端收到客户端发送的信息:Hello,我是7个,客户端!
线程名称Thread[pool-1-thread-5,5,main],服务端收到客户端发送的信息:Hello,我是2个,客户端!
线程名称Thread[pool-1-thread-5,5,main],服务端收到客户端发送的信息:Hello,我是0个,客户端!
线程名称Thread[pool-1-thread-1,5,main],服务端收到客户端发送的信息:Hello,我是1个,客户端!
线程名称Thread[pool-1-thread-5,5,main],服务端收到客户端发送的信息:Hello,我是3个,客户端!
线程名称Thread[pool-1-thread-1,5,main],服务端收到客户端发送的信息:Hello,我是4个,客户端!

本例中测试的客户端数量是 10,服务端使用 java 线程池来处理任务,线程数量为 5 个,服务端不用为每个客户端都创建一个线程,由于线程池可以设置消息队列的大小和最大线程数,因此它的资源占用是可控的,无论多少个客户端并发访问,都不会导致资源的耗尽和宕机。

在活动连接数不是特别高的情况下,这种模型还是不错的,可以让每一个连接专注于自己的 I/O 并且编程模型简单,也不用过多考虑系统的过载、限流等问题。

但是,它的底层仍然是同步阻塞的 BIO 模型,当面对十万甚至百万级请求接入的时候,传统的 BIO 模型无能为力,因此我们需要一种更高效的 I/O 处理模型来应对更高的并发量。

四、NIO

NIO,英文全称: Non-blocking-IO ,一种同步非阻塞的 I/O 模型。

在 Java 1.4 中引入,对应的代码在java.nio包下。

与传统的 IO 不同,NIO 新增了 Channel、Selector、Buffer 等抽象概念, 支持面向缓冲、基于通道的 I/O 数据传输方法

NIO 模型图,如下图:

网络数据传输

与此同时,NIO 还提供了与传统 BIO 模型中的 SocketServerSocket 相对应的 SocketChannelServerSocketChannel 两种不同的套接字通道实现。

NIO 这两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的 BIO 一样,比较简单,但是性能和可靠性都不好; 非阻塞模式正好与之相反

对于低负载、低并发的应用程序,可以使用同步阻塞 I/O 来提升开发效率和更好的维护性;对于高负载、高并发的( 网络 )应用,使用 NIO 的非阻塞模式来开发可以显著的提升数据传输效率。

在介绍样例之前,我们先看一下 NIO 涉及到的核心关联类图,如下:

网络数据传输

上图中有三个关键类: Channel 、Selector 和 Buffer ,它们是 NIO 中的核心概念。

  • Channel:可以理解为通道;
  • Selector:可以理解为选择器;
  • Buffer:可以理解为数据缓冲区;

从名词上看感觉很抽象,我们还是用之前介绍的城市交通工具来继续形容 NIO 的工作方式,这里的 Channel 要比 Socket 更加具体,它可以比作为某种具体的交通工具,如汽车或是高铁、飞机等,而 Selector 可以比作为一个车站的车辆运行调度系统,它将负责监控每辆车的当前运行状态,是已经出站还是在路上等等,也就是说它可以轮询每个 Channel 的状态。

还有一个 Buffer 类,你可以将它看作为 IO 中 Stream ,但是它比 IO 中的 Stream 更加具体化,我们可以将它比作为车上的座位,Channel 如果是汽车的话,那么 Buffer 就是汽车上的座位,Channel 如果是高铁上,那么 Buffer 就是高铁上的座位,它始终是一个具体的概念,这一点与 Stream 不同。

Socket 中的 Stream 只能代表是一个座位,至于是什么座位由你自己去想象,也就是说你在上车之前并不知道这个车上是否还有座位,也不知道上的是什么车,因为你并不能选择,这些信息都已经被封装在了运输工具( Socket )里面了。

NIO 引入了 Channel、Buffer 和 Selector 就是想把 IO 传输过程中涉及到的 信息具体化 ,让程序员有机会去控制它们。

当我们进行传统的网络 IO 操作时,比如调用write()往 Socket 中的SendQ队列写数据时,当一次写的数据超过SendQ长度时,操作系统会按照SendQ 的长度进行分割的,这个过程中需要将用户空间数据和内核地址空间进行切换,而这个切换不是程序员可以控制的,由底层操作系统来帮我们处理。

而在Buffer中,我们可以控制Buffercapacity(容量),并且是否扩容以及如何扩容都可以控制。

理解了这些概念后我们看一下,实际上它们是如何工作的呢?

我们一起来看看代码实例!

服务端操作,样例程序如下

/**
 * NIO 服务端
 */
public class NioServerTest {

    public static void main(String[] args) throws IOException {
        // 打开服务器套接字通道
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 服务器配置为非阻塞
        ssc.configureBlocking(false);
        // 进行服务的绑定,监听8080端口
        ssc.socket().bind(new InetSocketAddress(8080));

        // 构建一个Selector选择器,并且将channel注册上去
        Selector selector = Selector.open();
        // 将serverSocketChannel注册到selector,并对accept事件感兴趣(serverSocketChannel只能支持accept操作)
        ssc.register(selector, SelectionKey.OP_ACCEPT);

        while (true){
            // 查询指定事件已经就绪的通道数量,select方法有阻塞效果,直到有事件通知才会有返回,如果为0就跳过
            int readyChannels = selector.select();
            if(readyChannels == 0) {
                continue;
            };
            //通过选择器取得所有key集合
            Set< SelectionKey > selectedKeys = selector.selectedKeys();
            Iterator< SelectionKey > iterator = selectedKeys.iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                //判断状态是否有效
                if (!key.isValid()) {
                    continue;
                }
                if (key.isAcceptable()) {
                    // 处理通道中的连接事件
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel sc = server.accept();
                    sc.configureBlocking(false);
                    System.out.println("接收到新的客户端连接,地址:" + sc.getRemoteAddress());

                    // 将通道注册到选择器并处理通道中可读事件
                    sc.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    // 处理通道中的可读事件
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    while (channel.isOpen() && channel.read(byteBuffer) != -1) {
                        // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
                        if (byteBuffer.position() > 0) {
                            break;
                        };
                    }
                    byteBuffer.flip();

                    //获取缓冲中的数据
                    String result = new String(byteBuffer.array(), 0, byteBuffer.limit());
                    System.out.println("收到客户端发送的信息,内容:" + result);

                    // 将通道注册到选择器并处理通道中可写事件
                    channel.register(selector, SelectionKey.OP_WRITE);
                } else if (key.isWritable()) {
                    // 处理通道中的可写事件
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    byteBuffer.put("server send".getBytes());
                    byteBuffer.flip();
                    channel.write(byteBuffer);

                    // 将通道注册到选择器并处理通道中可读事件
                    channel.register(selector, SelectionKey.OP_READ);
                    //写完之后关闭通道
                    channel.close();
                }
                //当前事件已经处理完毕,可以丢弃
                iterator.remove();
            }
        }
    }
}

客户端操作,样例程序如下

/**
 * NIO 客户端
 */
public class NioClientTest {

    public static void main(String[] args) throws IOException {
        // 打开socket通道
        SocketChannel sc = SocketChannel.open();
        //设置为非阻塞
        sc.configureBlocking(false);
        //连接服务器地址和端口
        sc.connect(new InetSocketAddress("127.0.0.1", 8080));
        while (!sc.finishConnect()) {
            // 没连接上,则一直等待
            System.out.println("客户端正在连接中,请耐心等待");
        }

        // 发送内容
        ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
        writeBuffer.put("Hello,我是客户端".getBytes());
        writeBuffer.flip();
        sc.write(writeBuffer);

        // 读取响应
        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
        while (sc.isOpen() && sc.read(readBuffer) != -1) {
            // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
            if (readBuffer.position() > 0) {
                break;
            };
        }
        readBuffer.flip();

        String result = new String(readBuffer.array(), 0, readBuffer.limit());
        System.out.println("客户端收到服务端:" + sc.socket().getRemoteSocketAddress() + ",返回的信息:" + result);

        // 关闭通道
        sc.close();
    }
}

最后,依次启动服务端、客户端,看看控制台输出情况如何。

服务端控制台结果如下:

接收到新的客户端连接,地址:/127.0.0.1:57644
收到客户端发送的信息,内容:Hello,我是客户端

客户端控制台结果如下:

客户端收到服务端:/127.0.0.1:8080,返回的信息:server send

从编程上可以看到,NIO 的操作比传统的 IO 操作要复杂的多

Selector 被称为选择器 ,当然你也可以翻译为多路复用器 。它是Java NIO 核心组件中的一个,用于检查一个或多个 Channel (通道)的状态是否处于 连接就绪接受就绪可读就绪可写就绪

如此可以实现单线程管理多个 channels 的目的,也就是可以管理多个网络连接。

使用 Selector 的好处在于 :相比传统方式使用多个线程来管理 IO,Selector 使用了更少的线程就可以处理通道了,并且实现网络高效传输!

虽然 Java 中的 nio 传输比较快,为什么大家都不愿意用 JDK 原生 NIO 进行开发呢?

从上面的代码中大家都可以看出来,除了编程复杂之外,还有几个让人诟病的问题:

  • JDK 的 NIO 底层由 epoll 实现,该实现饱受诟病的空轮询 bug 会导致 cpu 飙升 100%!
  • 项目庞大之后,自行实现的 NIO 很容易出现各类 bug,维护成本较高!

但是,Netty 框架的出现,很大程度上改善了 JDK 原生 NIO 所存在的一些让人难以忍受的问题 ,关于 Netty 框架应用,会在后期的文章里进行介绍。

五、AIO

最后就是 AIO 了,全称 Asynchronous I/O,可以理解为异步 IO,也被称为 NIO 2,在 Java 7 中引入,它是异步非阻塞的 IO 模型。

异步 IO 是基于事件回调机制实现的,也就是应用操作之后会直接返回,不会堵塞在那里,当后台处理完成,操作系统会通知相应的线程进行后续的操作。

具体的实例如下!

服务端操作,样例程序如下

/**
 * aio 服务端
 */
public class AioServer {

    public AsynchronousServerSocketChannel serverChannel;

    /**
     * 监听客户端请求
     * @throws Exception
     */
    public void listen() throws Exception {
        //打开一个服务端通道
        serverChannel = AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));//监听8080端口
        //服务监听
        serverChannel.accept(this, new CompletionHandler< AsynchronousSocketChannel,AioServer >(){

            @Override
            public void completed(AsynchronousSocketChannel client, AioServer attachment) {
                try {
                    if (client.isOpen()) {
                        System.out.println("接收到新的客户端连接,地址:" + client.getRemoteAddress());
                        final ByteBuffer buffer = ByteBuffer.allocate(1024);
                        //读取客户端发送的信息
                        client.read(buffer, client, new CompletionHandler< Integer, AsynchronousSocketChannel >(){

                            @Override
                            public void completed(Integer result, AsynchronousSocketChannel attachment) {
                                try {
                                    //读取请求,处理客户端发送的数据
                                    buffer.flip();
                                    String content = new String(buffer.array(), 0, buffer.limit());
                                    System.out.println("服务端收到客户端发送的信息:" + content);

                                    //向客户端发送数据
                                    ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
                                    writeBuffer.put("server send".getBytes());
                                    writeBuffer.flip();
                                    attachment.write(writeBuffer).get();
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }

                            @Override
                            public void failed(Throwable exc, AsynchronousSocketChannel attachment) {
                                try {
                                    exc.printStackTrace();
                                    attachment.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        });
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //当有新客户端接入的时候,直接调用accept方法,递归执行下去,保证多个客户端都可以阻塞
                    attachment.serverChannel.accept(attachment, this);
                }
            }

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

    public static void main(String[] args) throws Exception {
        //启动服务器,并监听客户端
        new AioServer().listen();
        //因为是异步IO执行,让主线程睡眠但不关闭
        Thread.sleep(Integer.MAX_VALUE);
    }
}

客户端操作,样例程序如下

/**
 * aio 客户端
 */
public class AioClient {

    public static void main(String[] args) throws IOException, InterruptedException {
        //打开一个客户端通道
        AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
        //与服务器建立连接
        channel.connect(new InetSocketAddress("127.0.0.1", 8080));

        //睡眠1s,等待与服务器建立连接
        Thread.sleep(1000);
        try {
            //向服务器发送数据
            channel.write(ByteBuffer.wrap("Hello,我是客户端".getBytes())).get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            //从服务器读取数据
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            channel.read(byteBuffer).get();//将通道中的数据写入缓冲buffer
            byteBuffer.flip();
            String result = new String(byteBuffer.array(), 0, byteBuffer.limit());
            System.out.println("客户端收到服务器返回的内容:" + result);//输出返回结果
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

同样的,依次启动服务端程序,再启动客户端程序,看看运行结果!

服务端控制台结果如下:

接收到新的客户端连接,地址:/127.0.0.1:56606
服务端收到客户端发送的信息:Hello,我是客户端

客户端控制台结果如下:

客户端收到服务器返回的内容:server send

这种组合方式用起来十分复杂,只有在一些非常复杂的分布式情况下使用,像集群之间的消息同步机制一般用这种 I/O 组合方式。如 Cassandra 的 Gossip 通信机制就是采用异步非阻塞的方式,可以实现非常高的网络传输性能。

Netty 之前也尝试使用过 AIO,不过又放弃了!

六、小结

本文主要围绕 BIO、NIO、AIO 等模型,结合一些样例代码,做了一次简单的内容知识总结,希望对大家有所帮助。

打开APP阅读更多精彩内容
声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉

全部0条评论

快来发表一下你的评论吧 !

×
20
完善资料,
赚取积分