BIO-NIO-AIO网络IO模型

已于 2022-10-03 15:56:46 修改
阅读量424 收藏
点赞数
分类专栏： Netty 文章标签： java
于 2022-10-02 21:44:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianzhonghaoqing/article/details/127146740
版权

概述

BIO模型

Blocking IO（Input-Output）
在这里插入图片描述
模型是，一个线程对应一个客户端。
server中accept是阻塞的，client/server中socket读写也是阻塞的，性能很低。
代码简单示例如下：

  • client
package com.study.nettystudy.bio;

import java.io.IOException;
import java.net.Socket;

public class Client {

    public static void main(String[] args) {
        Socket socket = null;
        try {
            socket = new Socket("127.0.0.1", 8888);
            socket.getOutputStream().write("hello server".getBytes());
            final byte[] bytes = new byte[1024];
            final int len = socket.getInputStream().read(bytes);
            System.out.println(new String(bytes, 0, len));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  • server
package com.study.nettystudy.bio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Objects;

public class Server {

    public static void main(String[] args) throws IOException {
        final ServerSocket ss = new ServerSocket();
        ss.bind(new InetSocketAddress("127.0.0.1", 8888));
        while (true) {
            final Socket socket = ss.accept();
            new Thread(() -> {
                handle(socket);
            }).start();
        }
    }

    private static void handle(Socket socket) {
        try {
            byte[] bytes = new byte[1024];
            int len = socket.getInputStream().read(bytes);
            System.out.println(new String(bytes, 0, len));
            socket.getOutputStream().write(bytes, 0, len);
            socket.getOutputStream().flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (Objects.nonNull(socket)) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

NIO模型

NIO单线程模型

在这里插入图片描述
概念：selector（监听器）通过主动轮询的方式，监听不同socket上感兴趣的事件（socket connect、read、write）等，定时轮询到有事件发生，然后处理发生的事件，只有一个selector线程在维护所以客户端的连接、读写等事件；相当于一个selector监听多个socket上的连接、读写等事件，selector轮询感知到有些socket上发生感兴趣的事件时到进行处理。

代码示例

server端代码

package com.study.nettystudy.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress("127.0.0.1", 8888));
        ssc.configureBlocking(false);
        System.out.println("server started");
        Selector selector = Selector.open();
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            // 阻塞方法，当注册在selector上的key有事件发生时(事件由操作系统通知)返回
            selector.select();
            final Set<SelectionKey> keys = selector.selectedKeys();
            final Iterator<SelectionKey> it = keys.iterator();
            while (it.hasNext()) {
                final SelectionKey key = it.next();
                // 删除，否则下个循环重复处理
                it.remove();
                handle(key);
            }
        }
    }

    private static void handle(SelectionKey key) {
        if (key.isAcceptable()) {
            try {
                ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                SocketChannel sc = ssc.accept();
                sc.configureBlocking(false);
                sc.register(key.selector(), SelectionKey.OP_READ);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else if(key.isReadable()) {
            final SocketChannel sc = (SocketChannel) key.channel();
            final ByteBuffer buffer = ByteBuffer.allocate(512);
            buffer.clear();
            try {
                final int len = sc.read(buffer);
                if (len != -1) {
                    System.out.println(new String(buffer.array(), 0, len));
                }
                final ByteBuffer bufferWrite = ByteBuffer.wrap("Hello Client".getBytes());
                sc.write(bufferWrite);
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if (sc != null) {
                    try {
                        sc.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

Client端代码与Bio的相同，无需改变。

NIO-Reactor模式

NIO响应式模式，一个selector（只负责监听accecpt链接事件），读写事件交给worker线程池处理，减少selector处理时间，提供系统的吞吐量。
在这里插入图片描述
代码示例

package com.study.nettystudy.nio;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolServer {

    private final ExecutorService pool = Executors.newFixedThreadPool(50);

    private Selector selector;

    public static void main(String[] args) throws IOException {
        final PoolServer poolServer = new PoolServer();
        poolServer.initServer(8888);
        poolServer.listen();
    }

    public void initServer(int port) throws IOException {
        final ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.bind(new InetSocketAddress("127.0.0.1", port));
        selector = Selector.open();
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("pool server started");
    }

    public void listen() throws IOException {
        while (true) {
            selector.select();
            final Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                final SelectionKey key = iterator.next();
                iterator.remove();
                if (key.isAcceptable()) {
                    final ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                    final SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    sc.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    key.interestOps(key.interestOps() & (~SelectionKey.OP_READ));
                    pool.execute(new ThreadHandler(key));
                }
            }
        }
    }
}

class ThreadHandler implements Runnable {

    private final SelectionKey key;

    ThreadHandler(SelectionKey key) {
        this.key = key;
    }

    @Override
    public void run() {
        final SocketChannel channel = (SocketChannel) key.channel();
        final ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        byteBuffer.clear();

        final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        try {
            int size = 0;
            while ((size = channel.read(byteBuffer)) > 0) {
                byteBuffer.flip();
                byteArrayOutputStream.write(byteBuffer.array(), 0, size);
                byteBuffer.clear();
            }
            byteArrayOutputStream.close();
            final byte[] readBytes = byteArrayOutputStream.toByteArray();
            System.out.println(new String(readBytes));
            final ByteBuffer writeBuffer = ByteBuffer.allocate(readBytes.length);
            writeBuffer.put(readBytes);
            writeBuffer.flip();
            channel.write(writeBuffer);
            if (size == -1) {
                channel.close();
            } else {
                key.interestOps(key.interestOps() | SelectionKey.OP_READ);
                key.selector().wakeup();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

AIO模型

无需selector不停的轮询，由操作系统通知我们，当有连接事件时，操作系统调用我们注册的观察者逻辑，读写的事件可以像NIO一样交给线程池处理。
在这里插入图片描述
代码示例

package com.study.nettystudy.aio;

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;

public class Server {
    public static void main(String[] args) throws IOException, InterruptedException {
        final AsynchronousServerSocketChannel assc = AsynchronousServerSocketChannel.open();
        assc.bind(new InetSocketAddress("127.0.0.1", 8888));
        assc.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Object attachment) {
                assc.accept(null, this);
                final ByteBuffer buffer = ByteBuffer.allocate(1024);
                client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        attachment.flip();
                        System.out.println(new String(attachment.array()));
                        client.write(ByteBuffer.wrap("HelloClient1".getBytes()));
                    }

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

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

        while (true) {
            Thread.sleep(1000);
        }
    }
}

整个代码使用观察者模式，把accept的处理逻辑注册到操作系统面，io的读逻辑注册到操作系统，当有accept连接时，由操作系统调用注册的逻辑。相当于是我们观察操作系统的socket连接、读等事件，当有事件发送时，操作系统通知我们。

小结

NIO，AIO在Linux操作系统底层都是使用epoll（事件轮询）机制，因此AIO在操作系统层面还是和NIO一样都是轮询机制，只是AIO在java 层面把操作系统的轮询机制封装成了异步通知模式。
因此，Netty是对NIO模式的封装，接口看起来和AIO的类似。

融极
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
bio-nio-aio.zip
08-14
本文将深入探讨Java中的三种IO模型：传统IO（BIO）、非阻塞IO（NIO）以及反应器模式（Reactor），并结合提供的压缩包文件中的示例代码进行解析。 一、传统IO（BIO） 传统的Java IO基于流(Stream)进行数据传输，它...
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
01-04
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析 IO模型在计算机编程中扮演着至关重要的角色，特别是在网络通信中。Java提供了三种主要的IO模型：BIO（Blocking IO），NIO（Non-blocking IO），...
【知识积累】BIO&NIO&AIO模型快速实战
Darren的博客
05-24 234
本文源码：https://github.com/axin1240101543/netty（有什么问题可以提issue给我，一起学习，共同进步。） 一、BIO 1、BIOServer package com.darren.service.netty.bio; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; /** * <h3>netty</h3> *...
java实践11之网络IO BIO和NIO(上)
m252131895的博客
11-09 322
JAVA 网络IO BIO NIO 多路复用
Java网络编程IO模型 --- BIO、NIO、AIO详解
wanghuichen的博客
02-15 2986
通俗易懂详解 -- Java网络编程IO模型 BIO、NIO、AIO
JAVA IO模型（三）——网络IO之BIO,NIO,AIO
小不妞
10-21 243
目录 1.1. Java IO读写原理 1.1.1. 内核缓冲与进程缓冲区 1.1.2. java IO读写的底层流程 1.2. 四种主要的IO模型 1.3. 同步阻塞IO（Blocking IO） 1.4. 同步非阻塞NIO（None Blocking IO） 1.5. IO多路复用模型(I/O multiplexing） 1.6. 异步IO模型（asynchronous...
BIO、NIO、AIO三种IO模型的理解
学无止境！
03-27 2268
本文将对三种IO模型做简单的介绍和总结。 1、BIO模型 我们都知道，在做Java网络编程时，服务端的accept方法和read是阻塞的，直到有新连接进来或有数据可以读取，在阻塞期间线程不能干别的事情，这就是传统的BIO（blocking-io，同步阻塞IO）模型，显而易见，BIO模型在高并发场景下会面临服务端线程数过多浪费系统资源和频繁上下文切换问题。 BIO模型图如下： 2、NIO NIO，no blocking-io，或new io，是同步非阻塞IO。 这里介绍一下什么是同步，什么是阻塞： 同步指
Java网络编程IO模型 --- BIO、NIO、AIO详解(1)
2401_84102653的博客
05-01 458
作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料通过本文能加固你对BIO、NIO、AIO的理解作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料[外链图片转存中…(img-AZDmB8fc-1714500658587)][外链图片转存中…(img-3JMkjzjH-1714500658588)]本文已被。
IO-BIO-NIO-AIO
weixin_45203607的博客
05-04 278
介绍 什么是IO呢？什么是阻塞非阻塞IO？什么是同步异步IO？什么是IO多路复用？select/epoll跟IO模型有什么关系？有几种经典IO模型呢？BIO、NIO、AIO到底有什么区别的？ 什么是IO呢？ IO，英文全称是Input/Output，翻译过来就是输入/输出。平时我们听得挺多，就是什么磁盘IO，网络IO。那IO到底是什么呢？是不是有种懵懵懂懂的感觉呀，好像大概知道它是什么，又好像说不清楚。 IO，即输入/输出，到底谁是输入？谁是输出呢？IO如果脱离了主体，就会让人疑惑。 计算机角度的IO 我们
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO 三种模型，并提供了完整的实例代码。 BIO（Blocking I/O） BIO 是传统的同步阻塞模型，服务器端使用 ServerSocket 监听客户端的连接请求，客户端...
一站式学习Java网络编程 全面理解BIO:NIO:AIO1
08-08
全面理解 Java 网络编程 - BIO、NIO、AIO 本课程旨在帮助学生全面理解 Java 网络编程中的 BIO、NIO、AIO 三剑客，掌握 RPC 编程的基础知识，并结合实战项目巩固所学。 一、网络编程三剑客 - BIO、NIO、AIO BIO...
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
"Java中网络IO的实现方式（BIO、NIO、AIO）介绍" Java中网络IO的实现方式是指在Java语言中实现网络输入/输出操作的方法。根据不同的实现方式，可以分为三种：BIO（Blocking I/O）、NIO（Non-Blocking I/O）和AIO...
golang 接口
m0_70982551的博客
07-24 845
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 375
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 470
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 526
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 456
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java高级IO技术解析：BIO、NIO与AIO
这篇资料主要探讨了Java中的高级IO概念，特别是对比了三种不同的IO模型：BIO（Blocking I/O）、NIO（New I/O）和AIO（Asynchronous I/O），以及在Java中实现IO多路复用的select和poll方法的区别。 1. BIO与NIO的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

融极

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

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

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

打赏作者

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

抵扣说明：

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

余额充值