Java常见的IO模型

已于 2023-02-20 20:40:10 修改
阅读量58 收藏
点赞数
分类专栏： Java 文章标签： 服务器 java 网络
于 2023-02-20 15:55:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46612024/article/details/129124985
版权
  • 最基本的就是基于Socket的通信，统称为BIO，意味着同步阻塞通信。有消息也好，没消息也好，都会等待接收。通信的A、B两方，一直连接着，当发出请求后，持续等待另一方返回响应，不返回就一直等待，性能较差。当一方请求下线，另一方也是，体现了同步的特点，socket是两方紧紧耦合在一起的
  • 进阶的通信技术：NIO通信模式。同步非阻塞通信。当发出请求后，不需要持续等待另一方返回响应，可以过一会来查看是否有返回信息，不会一直等待阻塞。
  • 进阶的通信技术：NIO2.0（AIO通信）模式。异步非阻塞通信。有数据的时候通知，不需要请求方去访问，等待，性能较好

BIO通信模式下的案例介绍

案例1：一个客户端发消息，一个服务端收消息（这个案例只能发一次消息）

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动");
        //服务器注册一个端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //暂停接收客户端请求，得到一个端到端的socket管道
        Socket accept = serverSocket.accept();
        //从socket管道得到字节输入流
        InputStream inputStream = accept.getInputStream();
        //将字节输入流包装成自己想要的流读取
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        //读取数据
        String len;
        while ((len = bufferedReader.readLine()) != null) {
            System.out.println("服务端收到消息：" + len);
        }
    }
}
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        OutputStream outputStream = socket.getOutputStream();
        PrintStream printStream = new PrintStream(outputStream);
        printStream.println("客户端：我们开始交流吧");
        printStream.flush();
    }
}

        上述的服务端代码是有问题的，当客户端发送一次消息就结束了，socket是耦合的，客户端断开，服务器也断开了，那么当客户端再次发送的时候，服务端没有启动，会抛出Connection refused (Connection refused)异常，只支持一次发送。

案例2：客户端可以反复的发送消息，服务端可以反复的接收消息

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动===");
        //注册端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //这里暂停等待客户端的连接，得到一个端到端的socket管道
        Socket socket = serverSocket.accept();
        //从Socket中得到一个字节输入流
        InputStream inputStream = socket.getInputStream();
        //将流封装成需要的流对象，进去读取操作
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        //读取操作
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println("服务器收到：" + line);
        }
    }
}
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        Socket socket = new Socket("127.0.0.1", 8888);
        OutputStream outputStream = socket.getOutputStream();
        PrintStream printStream = new PrintStream(outputStream);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("请说");
            String msg = scanner.nextLine();
            printStream.println(msg);
            //这里不能写printStream.close();如果将流关闭了，socket是端到端的，服务器也就关闭，无法接收消息了
            printStream.flush();
        }
    }
}

        本案例可以实现多发多收，但是只能处理一个客户端的请求，当多个客户端连接时，只接收第一个客户端的请求，服务端是单线程的，一次只能和一个客户端进行通信。

案例3：一个服务端可以接收无数个客户端的连接，并且可以接收他们反复发送消息

public class ServerReadThread extends Thread {
    private Socket socket;
    public ServerReadThread(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String len;
            while ((len = bufferedReader.readLine()) != null) {
                System.out.println("服务端收到：" + socket.getRemoteSocketAddress() + "：" + len);
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(socket.getRemoteSocketAddress() + "下线了");
        }
    }
}
public class ServerDemo {
    /**
     * 思路：接收多个客户端，那么使用多个服务器线程来接收
     *
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动===");
        //注册端口
        ServerSocket serverSocket = new ServerSocket(8888);
        while (true) {
            Socket socket = serverSocket.accept();
            //创建多个客户端连接线程来接收消息
            new ServerReadThread(socket).start();
            System.out.println(socket.getRemoteSocketAddress() + "上线了");
        }
    }
}
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        Socket socket = new Socket("127.0.0.1", 8888);
        OutputStream outputStream = socket.getOutputStream();
        PrintStream printStream = new PrintStream(outputStream);
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("请说");
            String msg = scanner.nextLine();
            printStream.println(msg);
            //这里不能写printStream.close();如果将流关闭了，socket是端到端的，服务器也就关闭，无法接收消息了
            printStream.flush();
        }
    }
}
客户端1输出：
客户端启动
请说
1
请说
2
=========
客户端2输出：
客户端启动
客户端启动
请说
3
请说
4
=========
服务端输出：
服务器启动===
/127.0.0.1:59226上线了
服务端收到：/127.0.0.1:59226：1
服务端收到：/127.0.0.1:59226：2
/127.0.0.1:59231上线了
服务端收到：/127.0.0.1:59231：3
服务端收到：/127.0.0.1:59231：4

总结

  • 每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能
  • 每个线程都会占用栈空间和CPU资源
  • 并不是每个Socket都进行IO操作，无意义的线程处理
  • 客户端的并发访问增加时，服务器将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或僵死，从而无法对外提供服务

案例4：伪异步I/O通信方案

       提供一个线程池里面放固定的线程数，处理若干个客户端。将客户端的Socket封装成一个Task，交给后端线程池处理，JDK的线程池维护消息队列和N个活跃的线程，对消息队列中Socket任务进行处理。

  • 优点：无论有多少个客户端进行连接，线程数量是可控的，不会引起服务器的宕机和僵死
  • 缺点：虽然线程池可以固定线程数量，但是同时也只能处理这么多客户端，在满负荷状态下必须某个客户端断开连接，其他的客户端才可以接入
//线程池处理类
public class HandlerSocketThreadPool {
    //线程池
    private ExecutorService executorService;
    //线程池，最大运行3个，队列数最多为100个
    public HandlerSocketThreadPool(int maxPoolSize, int queueSize) {
        this.executorService = new ThreadPoolExecutor(3, maxPoolSize,
                120L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueSize));
    }
    public void execute(Runnable task) {
        this.executorService.execute(task);
    }
}
//读取客户端消息类
public class ReaderClientRunnable implements Runnable {
    private Socket socket;
    public ReaderClientRunnable(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String len;
            while ((len = bufferedReader.readLine()) != null) {
                System.out.println("服务器端收到了：" + len);
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("有人下线了");
        }
    }
}
//模拟客户端发请求
public class ClientDemo {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        //建立一个socket连接
        Socket socket = new Socket("127.0.0.1", 8888);
        //从socket管道中获取一个输出流，写数据到服务端
        OutputStream outputStream = socket.getOutputStream();
        //将输出流包装成打印流
        PrintWriter printStream = new PrintWriter(outputStream);
        //接收用户的输入
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String len;
        //写入消息
        while ((len = bufferedReader.readLine()) != null) {
            //注意，这里得使用println()，因为服务器端是readLine()读取的
            printStream.println(len);
            //为了将内存中的数据全部强制写出
            printStream.flush();
        }
    }
}
//服务器接收多个客户端的请求
public class ServerDemo {
    /**
     * 思路：接收多个客户端，那么使用多个服务器线程来接收
     *
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动===");
        try {
            //注册端口
            ServerSocket serverSocket = new ServerSocket(8888);
            //只需要一个服务端对应线程池，不需要每次都创建一个线程处理客户端的请求
            HandlerSocketThreadPool threadPool = new HandlerSocketThreadPool(3, 100);
            //客户端可能有多个
            while (true) {
                //阻塞式请求
                Socket socket = serverSocket.accept();
                System.out.println("有人上线了");
                //每次收到一个客户端的socket请求，都需求为该客户端分配一个线程，处理其请求
                threadPool.execute(new ReaderClientRunnable(socket));
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("有人下线了");
        }
    }
}

案例5：实现客户端与客户端通信消息（端口转发）

场景：适合固定通信个数的应用，不会引起宕机！伪异步实现的端口转发

思路：服务端要记录当前全部在线的客户端通道，一旦有一个客户端发来消息，服务端就把这个消息全部推送给全部在线的客户端通道

总结BIO思想

  • 同步阻塞式通信，一个线程处理一个客户端，而且是等着消息回复。
  • 伪异步I/O可以固定服务端的线程个数，不会引起高并发下宕机，但是同时只能处理若干个客户端，性能极差，只适合低并发，低负载的业务场景

NIO通信模式

       同步非阻塞式通信，性能较好，在没有消息的情况下，服务端可以去看其他通道是否有消息，服务端只提供一个线程去轮询所有的客户端，有就处理，没有就继续轮询。但是编程很复杂，调试也很麻烦，优点是性能较好，可以支持并发通信


说到Java通信，就不得不说开源框架Netty。Netty具备以下优点

  • API使用简单，开发门槛较低
  • 功能强大，预置了多种编码功能，支持多种主流协议
  • 定义能力强，可以通过ChannelHandler对通信框架进行灵活地扩展
  • 与其他NIO框架相比，Netty的综合性能最优
  • 成熟，稳定，Netty修复了已经发现的所有JDK NIO的Bug
芦蒿炒香干
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java中常见的I/O模型
weixin_45387320的博客
06-23 191
转载：原文链接 对Java中常见的四种I/O模型理解 1.1 知识科普1.1.1 同步阻塞I/O（Blocking I/O）1.1.1.1 阻塞与非阻塞1.1.1.2 同步与异步1.1.1.3 同步阻塞I/O 的具体流程1.1.1.4 阻塞I/O 的优点.
关于JAVA中的IO模型
lans_g的博客
05-13 834
一、java中IO的分类 java中的IO包括基本IO/BIO/NIO/AIO四种，其实主要是BIO/NIO/AIO三种IO模型。 二、基本IO 基本IO可以从两种方式上进行分类：传输方式和数据操作。 1.传输方式分类 （1）字节流：读取单个字节，处理二进制文件（图片，mp3，视频），主要是给计算机看的。 （2）字符流：读取单个字符，处理文本文件，主要是给人看的。 2.数据操作分类 三、BIO（阻塞IO） BIO就是blocking IO。最容易理解、最容易实现的IO工作方式，应用程序向操作系统请求网
Java 五大 IO 模型
qq_40970962的博客
05-29 280
文章目录1.阻塞IO模型2.非阻塞IO模型3.多路复用IO模型4.信号驱动IO模型5.异步IO模型 1.阻塞IO模型 最传统的一种IO模型，即在数据读写过程中会发生阻塞现象。当用户线程发出IO请求之后，内核回去查看线程是否准备就绪，没有就绪就等待数据就绪，而用户线程就会处于阻塞状态，用户线程交出CPU。 当数据准备就绪，内核将数据拷贝到用户线程，并返回结果给用户线程，用户线程才结束block状态。 典型的例子是: data = socket.read(); 如果数据没有就绪，就会一直阻塞在read()方法
java中的几种IO模型--BIO
宝良_阳明子的博客
02-05 159
java中的几种IO模型 我会陆续的讲解一下BIO/NIO/AIO的一些概念性的不同，并将其中的一些不同点做一下总结。这篇文章主要对BIO进行一些概念性的梳理。 一、传统的BIO 网络编程的基本模型是Clientt/Server模型，其中服务端负责提供位置信息（绑定ip和端口号）客户端负责通过连接操作向服务端监听的地址发送连接请求，通过三次握手建立连接。 1、BIO通信模型 传统的同步阻塞式通信模...
Java IO模型详解
m0_53157173的博客
09-26 415
IO 多路复用模型中，线程首先发起 select 调用，询问内核数据是否准备就绪，等内核把数据准备好了，用户线程再发起 read 调用。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。同步非阻塞 IO 模型中，应用程序会一直发起 read 调用，等待数据从内核空间拷贝到用户空间的这段时间里，线程依然是阻塞的，直到在内核把数据拷贝到用户空间。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。
Java三种IO模型原理实例详解
08-19
"Java三种IO模型原理实例详解" Java中的IO模型可以分为三种：BIO（同步阻塞）、NIO（同步非阻塞）和AIO（异步非阻塞）。每种模型都有其特点和应用场景。 BIO（同步阻塞） BIO是最古老的IO模型，在JDK1.4之前都是...
IO模型介绍,理解java常见的IO模型
07-02
IO模型介绍,理解java常见的IO模型
javaIO模型1
08-08
Java IO模型1主要涉及到的是Java在处理网络数据交互时的不同方式。这里有五种主要的IO模型，它们分别是阻塞IO（BIO）、非阻塞IO、IO多路复用、信号量和异步IO（AIO）。理解这些模型的关键在于区分同步与异步以及阻塞...
JavaNIO浅析IO模型Java开发Java经验技巧共1
11-22
本文将深入浅出地探讨Java NIO的基本概念、主要组件以及它如何改进了传统的IO模型。 一、Java NIO概述 在Java传统的IO模型中，IO操作基于流(Stream)进行，数据通常是单向流动的，且以字节或字符为单位。而NIO引入了...
Java IO 模型常见面试题总结 · .pdf
02-22
"Java IO 模型常见面试题总结" Java IO 模型是 Java 编程语言中的一种输入/输出机制，用于实现计算机系统与外部设备之间的通信过程。在计算机结构中，IO 描述了计算机系统与外部设备之间的通信过程。从应用程序的...
Java基础之IO模型
qq_40492693的博客
03-21 2077
面试喜欢问的操作系统问题:BIO,NIO,AIO
JAVA五种IO模型
热门推荐
weixin_44579258的博客
06-03 1万+
网络中获取数据的读操作步骤： 同步与异步： 同步与异步是针对应用程序与内核的交互而言。也就是上图的read操作，从缓存中读取数据，如果缓存中换没有准备好，如果是同步操作，它会一直等待，知道操作完成，如果是异步操作，那么他会去做别的事情，等待数据准备好，内核通知它，它再去读取数据 同步过程中进程触发IO操作并等待或者轮询的去查看IO操作是否完成。 异步过程中进程触发IO操作以后，直接返回，做自己的...
简单理解几种Java IO模型
格子的博客
08-09 9969
很多朋友在学习NIO的时候感觉比较吃力，对里面一些概念不是很明朗，本文杜撰了一个大嘴开饭店的故事，来类比Java IO模型的演变，帮助理解几种模型的功能和特点，IO分为磁盘IO和网络IO，本文讨论的都是网络IO。 爪哇村的大嘴做得一手好菜，原本是和平饭店的厨子，对吃的东西悟性很高，工作之余喜欢研究各种创新菜，最近自创一道麻辣小龙虾，顾客们吃后反响强烈，于是，大嘴想自立门户，专门开店经营小龙虾。 ......
常见的IO模型
晏无心的博客
07-12 2108
一、服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种： 1.同步阻塞IO（BlockingIO）：即传统的IO模型。 2.同步非阻塞IO（Non-blockingIO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（NewIO）库。 3.IO多路复用（IOMultiple...
Java NIO 系列教程
09-07 159
Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式。 Java NIO: Channels and Buffers（通道和缓冲区） 标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲
java常见的开发模型_java编程开发常见的五种IO模型
weixin_30320081的博客
02-24 255
IO操作是我们在学习java编程开发语言的时候需要重点掌握的一个编程技术，而今天我们就通过案例分析来了解一下，java编程开发常见的五种IO模型。1、BIOBIO是的一种IO方式，也是简单粗暴的方式，在发起IO操作之后，当前调用线程就会处在阻塞状态，直到数据传输完成。2、NIONIO是在BIO基础之上的一个改进，NIO在数据还未准备好的情况下，不会阻塞进程，而是通过轮询的方式，不断的去查询数据时候...
Java IO模型
qq_43646059的博客
06-14 1745
​   java三种IO模型思想解读
Linux：基础命令学习
qq_55038440的博客
07-20 1328
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
客户端与服务器通讯详解（5）：安全威胁与应对策略
最新发布
贝格前端工场的博客
07-23 592
在进行客户端与服务器通讯的时候，要时刻防范安全威胁，后端有一句名言“永远不要相信用户在前端的输入”，就是说客户端和服务器之间通讯，必须有严密的规则。
java io模型面试题
10-17
Java中的IO模型主要分为同步阻塞IO、同步非阻塞IO、多路复用IO和异步IO四种。其中，同步阻塞IO是最常见的一种，也是最简单的一种。在同步阻塞IO中，当一个线程调用read()或write()时，该线程会被阻塞，直到有数据可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

芦蒿炒香干

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

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

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

打赏作者

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

抵扣说明：

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

余额充值