BIO/NIO/AIO

最新推荐文章于 2024-09-11 09:06:50 发布
最新推荐文章于 2024-09-11 09:06:50 发布
阅读量74 收藏
点赞数
分类专栏： Java 文章标签： nio java 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43785387/article/details/125811599
版权
本文探讨了BIO、NIO和AIO在不同架构中的应用，重点介绍了AIO在高并发相册服务器中的优势，并剖析了伪异步服务端使用线程池的优点和局限性。通过实例展示了如何利用线程池避免线程耗尽，但指出其并未根本解决同步问题和队列阻塞。
摘要由CSDN通过智能技术生成

BIO：同步并阻塞，一般运用到连接数目少，固定的架构。这种方式对服务其资源要求比较高。

NIO：同步非阻塞，一般运用到连接数目多，数据比较短的架构。一般用在聊天室。

AIO：异步非阻塞，一般运用到连接数目多，数据比较长的架构。比如相册服务器，充分调用OS参与并发操作。

—————————————————————————————————————————————————————————

BIO：同步并阻塞

客户端：
socket
1.Socket对象请求与服务的连接
2.从Socket管道中获取输入、输出流读写数据
服务端：
Socket	
1.通过ServerSocket注册端口
2.服务端通过调用accept方法用于监听客户端的Socket请求
3从Socket中获取字节输入或者输出流进行数据的读写操作

服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端接受消息
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1.定义一个ServerSocket对象进行服务端的端口注册
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.监听客户端的连接请求
        Socket socket = serverSocket.accept();
        //3.从socket管道中得到字节输入流对象
        InputStream inputStream = socket.getInputStream();
        //4.把字节输入流转成字符输入流，然后包装成一个缓冲字符输入流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String msg;
        while ((msg = bufferedReader.readLine()) != null) {
            System.out.println("服务端接收到：" + msg);
        }
    }
}

客户端
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

/**
 * 客户端发送消息
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1.创建一个socket对象请求服务端的链接
        Socket socket = new Socket("127.0.0.1", 9999);
        //2.从socket对象中获取一个字节输出流
        OutputStream outputStream = socket.getOutputStream();
        //3.把字节输出流包装成一个打印流
        PrintStream printStream = new PrintStream(outputStream);
        //4.把数据打印出去
        printStream.print("hellp world！服务端，你好！");
        printStream.close();
    }
}

服务端持续接受消息
package com.example2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务端持续接受消息
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1.定义一个ServerSocket对象及逆行服务端的端口注册
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.监听客户端的socket连接请求
        Socket socket = serverSocket.accept();
        //3.从socket管道中得到一个字节输入流
        InputStream inputStream = socket.getInputStream();
        //4.把字节输入流转为为字符输入流，然后包装成缓存字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String msg;
        while ((msg = bufferedReader.readLine()) != null) {
            System.out.println("服务端接受到：" + msg);
        }
    }
}

客户端持续发送消息
package com.example2;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
 * 客户端持续发送消息
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1。创建socket对象请求服务端的链接
        Socket socket = new Socket("127.0.0.1", 9999);
        //2.从socket对象中获取一个字节输出流
        OutputStream outputStream = socket.getOutputStream();
        //3.把输出字节流包装成打印流
        PrintStream printStream = new PrintStream(outputStream);
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请说：");
            String msg = scanner.nextLine();
            printStream.println(msg);
            printStream.flush();
        }
    }
}

服务端实现接收多客户端消息
package com.example3;

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

/**
 * 服务端可以同时接收多个客户端的socket通信请求
 * 当服务端接收到客户端的socket请求对象时，都交给一个独立的线程来处理客户端的数据交互请求
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1。注册端口
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.定义一个死循环，负责不断接受客户端的socket链接请求
        while (true){
            Socket socket = serverSocket.accept();
            //3.创建一个独立的线程来处理与这个客户端的socket通信需求
            new ServerThreadReader(socket).start();
        }
    }
}

服务端多线程类
package com.example3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class ServerThreadReader extends Thread {
    private Socket socket;

    public ServerThreadReader(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //1.从socket对象中得到一个字节输入流
            InputStream inputStream = socket.getInputStream();
            //2.把字节输入流转为字符输入流，然后包装成缓存字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            while ((msg = bufferedReader.readLine()) != null) {
                 System.out.println("接受到客户端消息：" + msg);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多个客户端给服务端发送消息
package com.example3;

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
 * 客户端发送消息
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1。请求与服务端的socket对象链接
        Socket socket = new Socket("127.0.0.1",9999);
        //2.得到打印流
        PrintStream printStream = new PrintStream(socket.getOutputStream());
        //3.使用循环不断的发送小徐给服务端接收
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请说：");
            String msg = scanner.nextLine();
            printStream.println(msg);
            printStream.flush();
        }
    }
}

1.每个socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能
2.每个线程都会占用空间和CPU资源
3.并不是每个socket都进行IO操作，无意义的线程处理
4.客户端的并发访问增加时，服务端将呈现1:1的线程开销，访问量越大，系统就越可能崩溃死机

伪异步服务端
package com.example4;

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

/**
 * 开发伪异步通信框架
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1.注册端口
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.初始化一个线程池对象
        HandlerSocketServerPool handlerSocketServerPool = new HandlerSocketServerPool(6, 10);
        //3.定义一个循环接收客户端socket连接请求
        while (true) {
            Socket socket = serverSocket.accept();
            //4.把socket包装成任务
            Runnable target = new ServerRunnableTarget(socket);
            //5.把target任务对象交给一个线程池进行处理
            handlerSocketServerPool.execute(target);
        }
    }
}

服务端线程池
package com.example4;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class HandlerSocketServerPool {
    //1.创建1个线程池的成员变量。用于存储一个线程池对象
    private ExecutorService executorService;

    //2创建这个类的对象的时候就需要初始化线程池对象
    public HandlerSocketServerPool(int maxThreadNum, int queueSize) {
        executorService = new ThreadPoolExecutor(3, maxThreadNum, 120, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueSize));
    }
    //3.提供一个方法来提交任务给线程池的任务队列来暂存，等着线程池来处理
    public void execute(Runnable target){
        executorService.execute(target);
    }
}

伪异步线程任务runnable
package com.example4;

import java.io.*;
import java.net.Socket;

public class ServerRunnableTarget implements Runnable{
    private Socket socket;
    public ServerRunnableTarget(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            //1.从管道中得到1个字节流
            InputStream inputStream = socket.getInputStream();
            //2.把字节流包装成缓冲字符流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            while ((msg = bufferedReader.readLine())!=null){
                System.out.println("接收到客户端信息："+msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端
package com.example4;

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
 * 客户端发送消息
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1。请求与服务端的socket对象链接
        Socket socket = new Socket("127.0.0.1",9999);
        //2.得到打印流
        PrintStream printStream = new PrintStream(socket.getOutputStream());
        //3.使用循环不断的发送小徐给服务端接收
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请说：");
            String msg = scanner.nextLine();
            printStream.println(msg);
            printStream.flush();
        }
    }
}

1.伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽问题
2.由于底层依然使用同步并阻塞模型，因此无法从根本上解决问题
3.如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的io消息都在队列排队。
新的socket请求将被拒绝，客户端会发生大量连接超时。
学习两年半的Java实习生
关注
专栏目录
【Java基础】BIO/NIO/AIO的详细介绍与比较区分
weixin_45873353的博客
01-18 1491
BIO适用于连接数较少的场景 NIO适用于连接数目多且连接时间较短的架构，比如聊天服务器· AIO适用于连接数目多且连接时间较长的架构，比如相册服务器
java aio socket_Java Socket IO演进（一）-BIO/NIO/AIO
weixin_32900811的博客
03-06 248
1. 概览Java中主要有三种IO模型，分别是同步阻塞IO(BIO)、同步非阻塞IO(NIO)、异步非阻塞IO(AIO)。Java IO的演进，其实是依赖于操作系统的IO操作接口实现。比如在Linux 2.6以后，Java中NIO和AIO都是通过epoll来实现的；而在Windows上，AIO是通过IOCP来实现的。Linux(UNIX)操作系统中共有五种IO模型，分别是：阻塞IO模型、非阻塞IO...
【Netty系列】Netty/BIO/NIO/AIO
Love Peace
04-19 1076
Netty是一个开源的异步的事件驱动的网络应用框架，用于快速开发高性能的网络服务器和客户端。它主要用于构建可伸缩的网络应用程序，如协议服务器和客户端。Netty的设计目标是提供一个简单、快速、稳定的网络应用程序框架，同时保持灵活性和可扩展性。Netty基于NIO（非阻塞I/O）的事件驱动模型，使用了高效的线程池和优化的内存分配机制，使得它在处理大量并发连接时表现出色。Netty广泛用于构建各种类型的网络应用，包括Web服务器、游戏服务器、即时通讯系统等。
Java BIO/NIO/AIO 学习
taylorlannister的博客
12-25 295
一、了解Unix网络编程5种I/O模型 1.1、阻塞式I/O模型   阻塞I/O(blocking I/O）模型，进程调用recvfrom，其系统调用直到数据报到达且被拷贝到应用进程的缓冲区中或者发生错误才返回。进程从调用recvfrom开始到它返回的整段时间内是被阻塞的。 1.2、非阻塞式I/O模型 当一个应用进程像这样对一个非阻塞描述字循环调用recvfrom时，我们称之为轮...
深入理解BIO/NIO/AIO
Jak的博客
09-11 598
一、Java的I/O演进之路 1.1I/O 模型基本说明 I/O 模型： 就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能， Java 共支持 3 种网络编程的/IO 模型：BIO、NIO、AIO实际通信需求下，要根据不同的业务场景和性能需求决定选择不同的I/O模型 1.2 I/O模型 1.2.1 Java BIO 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理， 如果这..
BIO/NIO/AIO的具体实现
scofen的博客
11-01 500
  1、BIO编程     1.1、传统的BIO编程       网络编程的基本模型是C/S模型，即两个进程间的通信。     服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。     传统的同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操...
图解BIO/NIO/AIO
qq_42271561的博客
10-10 308
何为 I/O? I/O（Input/Outpu） 即输入／输出 。 根据大学里学到的操作系统相关的知识：为了保证操作系统的稳定性和安全性，一个进程的地址空间划分为 用户空间（User space） 和 内核空间（Kernel space ） 。 像我们平常运行的应用程序都是运行在用户空间，只有内核空间才能进行系统态级别的资源有关的操作，比如文件管理、进程通信、内存管理等等。也就是说，我们想要进行 IO 操作，一定是要依赖内核空间的能力。 并且，用户空间的程序不能直接访问内核空间。 当想要执行 IO 操作
【Java网络编程】基于BIO/NIO/AIO的多人聊天室（三）：NIO概述与实践
NoxUni的博客
10-31 325
课程《一站式学习Java网络编程 全面理解BIO/NIO/AIO》的学习笔记（三）： NIO概念 & 使用NIO进行文件拷贝 源码地址：https://github.com/NoxWang/web-program 一、NIO概述1.1 Buffer1.1.1 向Buffer中写入数据 一、NIO概述 NIO（Non-blocking IO 或 New IO），非阻塞式IO。与BIO不同，NIO使用Channel代替Stream，特征如下： Stream具有方向性，分为输入流和输出流，而Chan.
对于BIO/NIO/AIO，你还只停留在烧开水的水平吗？
Java笔记虾
07-04 642
点击上方“后端技术精选”，选择“置顶公众号”技术文章第一时间送达！推荐阅读(点击即可跳转阅读)1.SpringBoot内容聚合2.面试题内容聚合3.设计模式内容聚合...
深度讲解：同步/异步/阻塞/非阻塞/BIO/NIO/AIO
01-19
常规的误区 ... ... 　这个时候你问别人，刚刚代码发起的这个请求是不是一个同步请求，对方一定回答是。这是对的，它确实是。...对方一定是这样回答的，“因为发起请求后，代码就卡住不动了，直到拿到响应后才可以继续往下...
一站式学习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-28
Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码） Java 网络IO编程是 Java 编程语言中最重要的知识点之一，涉及到网络编程的各种技术和模型。本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO ...
struct 和 union 的区别
最新发布
weixin_47151388的博客
09-11 388
时需要特别小心，因为不正确的使用会导致数据混乱和不可预测的行为。则更为直观和安全，适用于大多数常见的场景。
问：JAVA NIO模型中selector/buffer/channel如何协作？
FIN技术铺掌柜的。
09-11 1241
本文介绍了Java NIO的三大核心概念：Selector、Channel与Buffer，并借助非阻塞服务器实例，深入解析了三者间的联系及作用。Selector监控多Channel，Channel执行I/O，Buffer作为数据传输媒介，三者协同构建了高效非阻塞I/O模型。
内网离线版 麒麟系统、统信欧拉版(UnionTech OS Server 20)如何将内存CPU跑到百分八十
One_Piece111的博客
09-09 287
[TOC](内网离线版 麒麟系统、统信欧拉版(UnionTech OS Server 20)如何将内存CPU跑到百分八十)
NIO详细解释
Flying_Fish_roe的博客
09-11 1011
Java NIO通过非阻塞I/O、缓冲区和选择器等机制提供了更高效的I/O处理方式，特别适合处理高并发、大规模网络通信等场景。与传统I/O相比，NIO能够更好地利用系统资源，并且提供了更灵活的缓冲区操作。尽管NIO在编程上稍微复杂一些，但它的高效性和性能使其在需要高并发和高吞吐量的应用中非常有用。Java 7的NIO2更进一步简化了文件系统操作，使得Java开发者能够更方便地处理文件和异步I/O操作。
Java 远程通讯技术：基于流式套接字的网络编程(BIO、NIO、AIO)
iOS逆向与安全
09-11 336
通信的一方扮演客户机的角色，另一方扮演服务器的角色。当服务器端收到客户机发来的连接请求以后，服务器会接受客户机的连接请求，双方建立连接后，就可进行数据的传递。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议栈进行交互的接口。数据报文方式的应用场景：由于取消了重发校验机制，能达到较高的通讯速率，可以用作一些对数据可靠性要求不高的通讯，如。流方式的应用场景：通讯可靠，对数据有校验和重发的机制，通常用于数据文件的传输如。等， 适合于大量数据的传输。
问：聊一下NIO模型在Netty框架中的用法？
FIN技术铺掌柜的。
09-08 820
Netty是一个基于Java NIO的高性能网络应用框架，通过异步非阻塞I/O、事件驱动和高效线程模型，提供高性能、低资源消耗的网络编程解决方案。适用于高性能服务器、微服务架构和实时系统等场景，具有高度的可扩展性和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值