BIO剖析

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量185 收藏 1
点赞数
分类专栏： IO 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouhe_/article/details/125451016
版权

BIO

BIO模式下的多发与多收消息

  • Server
public class Server {
    public static void main(String[] args) {
        try {
            System.out.println("服务端启动 ---- ");
            // 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) { // while 读取完一行之后  此时Client已经断开 抛异常Connect reset
                System.out.println(msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • client
public class Client {
    public static void main(String[] args) {
        try {
            // 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 s = scanner.nextLine();
                printStream.println(s);
                printStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BIO模式下接收多个客户端

演示：Idea中开启服务端，同时开启两个客户端
注意： idea中开启多个客户端需要配置允许并发访问
请添加图片描述
现象：
请添加图片描述

请添加图片描述

请添加图片描述

问题：
服务端只接受了一个客户端的请求
分析：
服务端中开启了一个线程接受并处理，无法处理另一个socket
Socket socket = serverSocket.accept();

概述

在上述案例中，一个服务器只能接受一个客户端的通信请求，那么如果服务端需要处理很多个客户端的消息通信请求应该如何处理，此时我们就需要在服务端引入线程了，也就是说客户端每发一个请求，服务端就创建一个新的线程来处理这个客户端的请求，这样就实现了一个客户端一个线程的模型，图解模式如下：
请添加图片描述

代码实现

  • server
/**
 * 目标：实现服务端可以同时接收多个客户端的Socket通信需求
 * 思路：是服务端每接收一个客户端socket请求对象之后都交由一个独立的线程处理
 */
public class Server {
    public static void main(String[] args) {
        try {
            // 1. 注册端口
            ServerSocket ss = new ServerSocket(9999);
            System.out.println("服务端启动了 --");
            // 2. 定义一个死循环，负责不断的接收客户端的Socket连接请求
            while (true) {
                Socket socket = ss.accept(); // 阻塞
                System.out.println(Thread.currentThread().getId() + ": 主线程 -- ");
                // 3. 创建一个独立的线程处理这个客户端的请求
                new ServerThreadReader(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}





public class ServerThreadReader extends Thread{
    private Socket socket;
    public ServerThreadReader(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getId() + ":子线程 --");
        try {
            InputStream is = this.socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg = null;
            while ((msg = br.readLine()) != null){
                System.out.println(msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • client
public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1", 9999);
            OutputStream os = socket.getOutputStream();
            PrintWriter pw = new PrintWriter(os);
            Scanner sc = new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String s = sc.nextLine();
                pw.println(s);
                pw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

小结

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

伪异步I/O编程

概述

在上述案例中：客户端的并发访问增加时，服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能提供服务。
接下来我们采用一个伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的socket封装成一个Task（该任务实现java.lang。Runnable线程任务接口）交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息中的Socket任务进行处理，由线程池可以设置消息队列的大小和最大线程数，因此，他的资源占用是可以控制的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机
请添加图片描述

代码实现

  • server
public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket sc = new ServerSocket(9999);
            // 1. 创建线程池对象
            HandlerSocketServerPool serverPool = new HandlerSocketServerPool(10, 20);
            while (true){
                Socket socket = sc.accept();
                // 2. 封装成任务对象
                SocketRunnable socketRunnable = new SocketRunnable(socket);
                // 3. 交由线程池处理（当一个socket连接时，封装成任务对象，交由线程池处理，提交任务操作，让线程池去触发run方法）
                serverPool.execute(socketRunnable);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • threadPool
public class HandlerSocketServerPool {
    // 1. 创建一个线程池的成员变量用于存储一个线程池对象
    private ExecutorService executorService;

    /**
     * 创建这个类的对象时候就需要初始化线程池对象
     *
     * @param maxThreadNum
     * @param queueSize
     */
    public HandlerSocketServerPool(int maxThreadNum, int queueSize) {
        executorService = new ThreadPoolExecutor(3,
                maxThreadNum, 120,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize));
    }

    /**
     * 提供一个方法来提交任务给线程池的任务队列来暂存，等着线程池来处理
     * @param target
     */
    public void execute(Runnable target){
        executorService.execute(target);
    }

}
  • task
public class SocketRunnable implements Runnable {
    private Socket socket;
    public SocketRunnable(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            InputStream is = this.socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg = null;
            while ((msg = br.readLine()) != null) {
                System.out.println(msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

小结

  • 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成了线程资源耗尽问题，但由于底层依然是采用的异步阻塞模型，因此无法从根本上解决问题
  • 如果单个消息处理缓慢，或者服务器线程中的全部线程都被阻塞，那么后续socket的io消息将在队列中排队。新的Socket请求将被拒绝，客户端发生大量连接超时

BIO实现任意类型文件上传

  • client
/**
 * 目标：实现客户端上传任意类型的文件数据给服务端保存起来
 */
public class Client {
    public static void main(String[] args) {
        try {
            // 1. 请求与服务端的Socket连接
            Socket socket = new Socket("127.0.0.1", 9999);
            // 2. 把字节输出流封装成一个数据输出流
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            // 3. 发送文件后缀
            dos.writeUTF(".png");
            // 4. 发送文件
            FileInputStream fis = new FileInputStream("/Users/mac/Desktop/111.png");
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) > 0) {
                dos.write(buffer,0,len);
            }
            dos.flush();
            socket.isOutputShutdown(); // 通知服务端这边数据发送完毕

            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • server
public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9999);
            while (true) {
                Socket socket = ss.accept();
                new ServerReaderThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}




public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 1. 得到一个数据输入流读取客户端发来的数据
            DataInputStream dis = new DataInputStream(this.socket.getInputStream());
            // 2. 获取文件类型
            String suffix = dis.readUTF();
            System.out.println("服务端已成功接收文件类型："+suffix);
            // 3. 定义一个字节输出管道负责把客户端发来的数据写进去
            OutputStream os = new FileOutputStream("/Users/mac/IdeaProjects/spring-demos/netty-demo/src/com/zhj/static/" + UUID.randomUUID() + suffix);
            // 4. 从数据输入流中读取数据，写到字节输出流去
            byte[] buffer = new byte[1024];
            int len;
            while ((len = dis.read(buffer)) > 0) {
                os.write(buffer,0,len);
            }
            os.close();
            System.out.println("文件接收完毕！");

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

基于BIO模式下的端口转发思想

需求： 需要实现一个客户端的消息可以发送给所有的客户端去接收
请添加图片描述

/**
 * 目标： BIO模式下端口转发思想-服务端实现
 *
 * 服务端实现的需求：
 *  1. 注册端口
 *  2. 接收客户端的socket连接，交给一个独立的线程来处理
 *  3. 把当前连接的客户端socket存入到所谓的在线socket集合中保存
 *  4. 接收客户端的消息，然后推送给当前所有的在线socket接收
 */
public class Server {
    // 定义一个静态集合
    public static List<Socket> allSocketOnLine = new ArrayList();

    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(9999);
            while (true){

                Socket socket = ss.accept();
                // 把登录的客户端socket存入到一个在线的集合中去
                allSocketOnLine.add(socket);
                // 为当前登录成功的socket分配一个独立的线程来处理
                new ServerReaderThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}





public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String msg;
            while ((msg = br.readLine()) != null) {
                // 发送给所有的在线socket
                sendMsgToAllClient(msg);
            }
        } catch (Exception e) {
            System.out.println("有人下线了");
            Server.allSocketOnLine.remove(socket);
        }

    }

    /**
     * 把当前客户端发来的消息发送给全部的在线socket
     * @param msg
     */
    private void sendMsgToAllClient(String msg) throws IOException {
        for (Socket sk : Server.allSocketOnLine) {
            PrintWriter pw = new PrintWriter(sk.getOutputStream());
            pw.println(msg);
            pw.flush();
        }
    }
}

BIO即时通讯

参考 ： https://blog.csdn.net/unique_perfect/article/details/115108640

归去来兮★
关注
专栏目录
BIO示例及分析
qq_43039260的博客
08-20 79
BIO示例及分析 BIO示例代码 package com.atguigu.bio; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class BIOServer { public static voi
BIO从提交到执行完毕过程分析
大隐隐于野
05-28 309
6.调用q->prep_rq_fn()对取得的request初始化,以sd_prep_fn()为例,此函数会调用scsi_get_cmd_from_req()构造scsi_cmnd,调用scsi_init_io()初始化scsi_cmnd,scsi_init_io()又会调用scsi_init_sgtable()用requst中的biovec初始化scsi_cmnd中的scatter-gather链表.
bio metastas分析
五月的田野
09-01 1125
Metastats是用于检测宏基因组病例/对照研究中差异丰富特征的软件。它是在包含多个样本的宏基因组数据的背景下开发的第一个工具，并且依赖于非参数t检验。 相关资源 - 介绍 http://cbcb.umd.edu/software/metastats - 计算 源代码 https://github.com/icj/Metagenomics - mothur metastats http...
Netty剖析之BIO
皓晨的架构笔记
01-30 271
什么是BIO？ BIO(blocking I/O)，同步阻塞IO，服务器实现模式为一个线程处理一个连接，即每当有一个客户端连接时，就会启动一个独立的线程来进行处理，如果这个连接不做任何事情，就会阻塞到那里，从而引起不必要的线程开销； BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，程序简单易理解； BIO工作原理 服务器...
JAVA BIO深入剖析
m0_62943934的博客
12-13 1340
Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.ioBIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器).​ 在上述的案例中，一个服务端只能接收一个客户端的通信请求，那么如果服务端需要处理很多个客户端的消息通信请求应该如何处理呢​ 在上述案例中：客户端的并发访问增加时。
代码分析Java中的BIO与NIO
ifever的博客
08-08 648
通过学习BIO与NIO的相关概念，使用代码方式来实现BIO与NIO模型，进一步对其之间的异同作以理解。
BIO实例及分析
xidianzxm
04-12 289
public class BIOServer { public static void main(String[] args) throws Exception { //线程池机制 //思路 //1. 创建一个线程池 //2. 如果有客户端连接，就创建一个线程，与之通讯(单独写一个方法) Exe...
JAVA BIO
CICI❤️的博客
02-17 160
JAVA BIO深入剖析1. Java BIO 基本介绍2. Java BIO 工作机制3. 传统BIO编程4. BIO模式下的多发和多收消息5. BIO模式下接收多个客户端6. 伪异步I/O编程7. 基于BIO的文件上传8. Java BIO模式下的端口转发9. 基于BIO模式下的即时通信功能清单简单说明项目启动与演示 1. Java BIO 基本介绍 Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io BIO(blocking I/O) ： 同步阻塞，服务器实现
BLOCK层代码分析（1）数据的组织BIO
flyingnosky的专栏
11-13 2293
对于BLOCK层，表示一个IO的数据结构为BIO和request。对于request在后续的章节中做介绍，这里只介绍与BIO相关的结构体。 系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言...
bio
03-19
"bio"这个标题可能指的是生物信息学，这是一个交叉学科，结合了生物学、计算机科学和统计学，用于分析和解释生物数据。在网页开发中，HTML可以用来构建生物科学相关的网站，展示研究成果、基因序列、生物模型等信息...
Bio-Rad CFX 定量PCR软件包
07-10
Bio-Rad CFX定量PCR软件包是用于分析和管理Bio-Rad公司生产的CFX系列定量聚合酶链式反应（qPCR）数据的专业工具。在生物学研究领域，定量PCR是一种广泛使用的分子生物学技术，用于检测和量化特定DNA序列的拷贝数。这...
Bio-Rad-Image-Lab-Software-6.1-Windows.zip
06-16
Bio-Rad Image Lab Software是一款专为凝胶成像设计的专业软件，主要应用于生命科学领域，尤其是分子生物学实验中对DNA、RNA和蛋白质电泳凝胶的分析。此软件的6.1版本是针对Windows操作系统设计的，提供了强大的图像...
Bio133
03-07
在"Bio133"的背景下，Jupyter Notebook可能是学生或研究人员用来分析生物数据、记录实验步骤、创建可视化图表和构建模型的工具。通过这种方式，他们可以更直观地理解和解释生物学现象。 【压缩包子文件的文件名称...
Bio7-开源
04-27
Bio7应用程序是用于生态建模的集成开发环境，并且包含用于模型创建，科学图像分析和统计分析的强大工具。 该应用程序本身基于RCP-Eclipse环境（Rich-Client-Platform），由于其插件结构和自定义的可能性，因此在配置...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 570
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 674
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 698
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1206
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
python BIO
06-06
BIO（ Beginning-Inside-Outside）是生物信息学中用于标记文本序列的一种常见方法，尤其是在序列标注任务中，如命名实体识别（NER）。在Python中，BIO用于处理和分析带有实体标记的文本数据，这些标记帮助理解文本中的实体类型和它们的边界。 在BIO体系中，有三种基本的标记： 1. **B-**（Beginning）：表示一个实体的开始，后面紧跟着的是实体的名称。 2. **I-**（Inside）：当一个词属于已经开始的实体时，使用这个标记，表示实体的内部部分。 3. **O**（Outside）：如果一个词不属于任何已知的实体，就标记为“ Outside”。 例如，考虑句子 "John works at Google." 对于这个句子，"Google" 可能被标记为一个组织名，那么标记会是： - "John"：O - "works"：O - "at"：O - "Google"：B-ORG (表示"组织名"的开始)

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值