BIO-NIO-AIO网络IO模型

已于 2022-10-03 15:56:46 修改
阅读量423 收藏
点赞数
分类专栏： 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
IO模型决定了数据的传输方式，Java支持BIO，NIO，AIO三种IO模型。BIO是同步阻塞模型，特点是一对一的客户端与处理线程关系，适用场景是连接数量较小并且固定的，优点是编程简单，但对服务器资源要求高。NIO是同步非...
【知识积累】BIO&NIO&AIO模型快速实战
Darren的博客
05-24 232
本文源码：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 320
JAVA 网络IO BIO NIO 多路复用
Java网络编程IO模型 --- BIO、NIO、AIO详解
wanghuichen的博客
02-15 2962
通俗易懂详解 -- Java网络编程IO模型 BIO、NIO、AIO
JAVA IO模型（三）——网络IO之BIO,NIO,AIO
小不妞
10-21 242
目录 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 2259
本文将对三种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 424
作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料通过本文能加固你对BIO、NIO、AIO的理解作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料[外链图片转存中…(img-AZDmB8fc-1714500658587)][外链图片转存中…(img-3JMkjzjH-1714500658588)]本文已被。
IO-BIO-NIO-AIO
weixin_45203607的博客
05-04 276
介绍 什么是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中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
"Java中网络IO的实现方式（BIO、NIO、AIO）介绍" Java中网络IO的实现方式是指在Java语言中实现网络输入/输出操作的方法。根据不同的实现方式，可以分为三种：BIO（Blocking I/O）、NIO（Non-Blocking I/O）和AIO...
01-VIP-BIO，NIO，AIO精讲1
08-03
本篇文章将深入探讨三种主要的Java IO模型：BIO（ Blocking IO）、NIO（Non-Blocking IO）和AIO（Asynchronous IO），并以代码实例解析它们的工作原理和优缺点。 首先，我们来看BIO，即同步阻塞IO模型。在BIO中，每...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1142
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 473
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
JAVA中的异常超详解
2302_79993788的博客
07-01 825
通常使用java语言内置的异常类就可以描述在编写程序时出现的大部分情况，但是有些时候，程序员需要根据程序设计的需要来创建自己的异常类，用以描述java语言内置异常类所不能描述的一些特殊情况。下面就来介绍如何创建和如何自定义异常。自定义异常类必须继承自Throwable类，才能被视为异常类，通常是继承Throwable的子类Exception或者Exception类的子孙类。下面是一个实例来演示如何创建一个自定义异常类1、创建一个MYException异常类，它必须继承Exception类。
Java面试题: 什么情况下索引会失效
qq_55630615的博客
07-02 255
通过执行计划EXPLAIN可以判断索引是否失效如果KEY和KEY_LEN为空代表索引失效。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 414
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
2024年Java常见的-BIO,NIO,AIO,Netty面试题
04-20
主要是介绍java方面网络方面 网络通信方面的面试题，核心内容主要是关于BIO,NIO,AIO,Netty的面试，算是一套八股文吧，还是老话，该背的还是要背一背！！！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

融极

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

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

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

打赏作者

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

抵扣说明：

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

余额充值