BIO

最新推荐文章于 2023-07-08 01:43:15 发布
最新推荐文章于 2023-07-08 01:43:15 发布
阅读量79 收藏
点赞数
分类专栏： java 文章标签： 网络 多线程 java socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hahayixiao1/article/details/116662858
版权

Java BIO 基本介绍

  • Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io
  • BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器).

Java BIO 工作机制

在这里插入图片描述
对 BIO 编程流程的梳理

  1. 服务器端启动一个 ServerSocket，注册端口，调用accpet方法监听客户端的Socket连接。
  2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯

传统的BIO编程实例回顾

​1.网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信（绑定IP地址和端口），客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下进行三次握手连接，连接成功后，双方通过网络套接字（Socket）进行通信。
​2.传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址，启动监听端口；客户端Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
​ 基于BIO模式下的通信，客户端 - 服务端是完全同步，完全耦合的。

过程：
创建客户端对象：
（1）创建一个Socket的通信管道，请求与服务端的端口连接。
（2）从Socket管道中得到一个字节输出流。
（3）把字节流改装成自己需要的流进行数据的发送
创建服务端对象：
（1）注册端口
（2）开始等待接收客户端的连接,得到一个端到端的Socket管道
（3）从Socket管道中得到一个字节输入流。
（4）把字节输入流包装成自己需要的流进行数据的读取。

客户端案例如下

package one;

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) {
        try {
            Socket socket=new Socket("127.0.0.1",9999);
            OutputStream outputStream=socket.getOutputStream();
            PrintStream printStream=new PrintStream(outputStream);
            printStream.println("hello_world");
            printStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端案例

package one;

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

public class server {
    public static void main(String[] args) {
        ServerSocket ss;
        {
            try {
                ss = new ServerSocket(9999);
                Socket socket=ss.accept();
                InputStream inputStream=socket.getInputStream();
                BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
                String msg;
                while((msg = bufferedReader.readLine())!=null){
                    System.out.println("服务端收到"+msg);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：
在这里插入图片描述

小结

  • 在以上通信中，服务端会一致等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直进入阻塞状态。
  • 同时服务端是按照行获取消息的，这意味着客户端也必须按照行进行消息的发送，否则服务端将进入等待消息的阻塞状态！

BIO模式下多发和多收消息

在上述案例中，只能实现客户端发送消息，服务端接收消息，并不能实现反复的收消息和反复的发消息，我们只需要在客户端案例中，加上反复按照行发送消息的逻辑即可！案例代码如下：

服务端案例

package two;

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) {
        ServerSocket ss;

        {
            try {
                ss = new ServerSocket(9999);
                Socket socket=ss.accept();
                InputStream inputStream=socket.getInputStream();
                BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
                String msg;
                while((msg = bufferedReader.readLine())!=null){
                    System.out.println("服务端收到"+msg);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端案例

package two;

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) {
        try {
            Socket socket=new Socket("127.0.0.1",9999);
            OutputStream outputStream=socket.getOutputStream();
            PrintStream printStream=new PrintStream(outputStream);

            while(true){
                Scanner scanner=new Scanner(System.in);
                System.out.println("请输入消息:");
                String s = scanner.nextLine();
                printStream.println(s);
                printStream.flush();
            }

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

在这里插入图片描述
在这里插入图片描述

小结

  • 本案例中确实可以实现客户端多发多收
  • 但是服务端只能处理一个客户端的请求，因为服务端是单线程的。一次只能与一个客户端进行消息通信。

BIO模式下接收多个客户端

在这里插入图片描述

客户端

package three;

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) {
        try {
            Socket socket=new Socket("127.0.0.1",9999);
            OutputStream outputStream=socket.getOutputStream();
            PrintStream printStream=new PrintStream(outputStream);

            while(true){
                Scanner scanner=new Scanner(System.in);
                System.out.println("请输入消息:");
                String s = scanner.nextLine();
                printStream.println(s);
                printStream.flush();
            }

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

服务端

package three;

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) {
        ServerSocket ss;

        {
            try {
                ss = new ServerSocket(9999);
                while(true){
                    Socket socket=ss.accept();
                    new ServerThreadReader(socket).start();
                }

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


package three;

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() {
        InputStream inputStream= null;
        try {
            inputStream = socket.getInputStream();
            BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            while((msg = bufferedReader.readLine())!=null){
                System.out.println("服务端收到"+msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

小结

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

伪异步I/O编程

概述

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

客户端

package four;

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) {
        try {
            Socket socket=new Socket("127.0.0.1",9999);
            OutputStream outputStream=socket.getOutputStream();
            PrintStream printStream=new PrintStream(outputStream);

            while(true){
                Scanner scanner=new Scanner(System.in);
                System.out.println("请输入消息:");
                String s = scanner.nextLine();
                printStream.println(s);
                printStream.flush();
            }

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

服务端

package four;

import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) {
        try{
            ServerSocket socket=new ServerSocket(9999);
            HandleSocketServer handleSocketServer=new HandleSocketServer(6,10);
            while(true){
                Socket socket1=socket.accept();
                Runnable target=new ServerRunnableTarget(socket1);
                handleSocketServer.execute(target);
            }

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


package four;

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() {
        InputStream inputStream= null;
        try {
            inputStream = socket.getInputStream();
            BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            while((msg = bufferedReader.readLine())!=null){
                System.out.println("服务端收到"+msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}


package four;

import java.util.concurrent.*;

public class HandleSocketServer {
    private ExecutorService executorService;
    public HandleSocketServer(int maxThread,int QueueSize){
        executorService=new ThreadPoolExecutor(3,maxThread,2, TimeUnit.MINUTES, new ArrayBlockingQueue<Runnable>(QueueSize));
    }
    public void execute(Runnable target){
        executorService.execute(target);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Ha ha, a smile
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bio
03-19
生物
openssl bio
ughome的专栏
10-09 491
openssl bio例子
二、JAVA BIO
wang_luwei的博客
04-09 2255
NIO 目录 文章目录二、JAVA BIO1、 Java BIO基本介绍2、 java BIO工作机制3、传统的BIO编程实例回顾3.1、客户端案例如下3.2、服务端案例如下3.3、输出3.4、小结4、BIO模式下多发和多收消息4.1、客户端代码如下4.2、服务端代码如下4.3、输出5、BIO模式下接收多个客户端5.1、概述5.2、客户端案例代码5.3、服务端案例代码5.4、线程类5.5、输出5.6、小结6、伪异步I/O编程6.1、概述6.2、客户端案例代码6.3、服务端案例代码6.4、线程池处理类6.5
BIO标注
SmartDemo的博客
03-31 705
'id'：文章id'discourse_id'：描述id（一篇文章会有多个描述）'discourse_start'：该描述在文章的开始位置'discourse_end',：该描述在文章的结束位置'discourse_text'：具体内容'discourse_type'：描述类型（有Name_desc,Age_desc）Name_desc：姓名描述信息Age_desc：年龄描述信息'discourse_type_num'：该文章包含该类描述的个数。
bio的github代码实现
weixin_40857858的博客
10-23 261
bio的github代码实现
BIO、NIO、AIO详解
热门推荐
hxt的博客
08-15 1万+
一、Java的I/O演进之路 Java共支持3种网络编程的I/O模型：BIO、NIO、AIO BIO： 同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 NIO： 同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理 AIO： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求
BIO与NIO比较
liangcheng0213的博客
07-23 648
文章目录BIO 同步阻塞BIO介绍BIO的编程流程BIO实现通信实现思路：服务器：客户端： BIO 同步阻塞 服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动 一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 BIO介绍 Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.ioBIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做..
Linux bio数据结构
GetnextWindow的专栏
07-08 669
代码中newblock=map->m_lblk - ee_block + ee_start即是起始逻辑地址映射的磁盘块地址，allocated = ee_len - (map->m_lblk - ee_block)是成功映射的block数，注意未必等于map.m_len，有可能小于map.m_len，因为磁盘block未必有map.m_len个连续的块。ext4_mpage_readpages函数就会读取磁盘数据就会构建一个个的bio，如上面描述我们知道bio指向的是一块连续的磁盘数据，
OpenSSL BIO源码简析
Starr
12-19 1418
OpenSSL BIO源码简析
服务端的bio 模型
01-09
bio模型，每个客户端连接必须要有一个连接与之对应，性能较低
NIO、BIO介绍与对比
05-06
详细介绍NIO以及和BIO的对比，原有的 IO 是面向流的、阻塞的，NIO 则是面向块的、非阻塞的。
获取两个字符串中最大相同子串
hahayixiao1的博客
08-08 910
获取两个字符串中最大相同子串。比如： str1 = “abcwerthelloyuiodefabcdef”;str2 = “cvhellobnm” public String getMaxSameString(String str1,String str2){ if(str1 != null && str2 != null){ String maxStr = (str1.length() >= str2.length())? str1 : str
InputStreamReader和OutputStreamWriter
hahayixiao1的博客
08-18 852
InputStreamReader和OutputStreamWriter 1.转换流：属于字符流 InputStreamReader：将一个字节的输入流转换为字符的输入流 OutputStreamWriter：将一个字符的输出流转换为字节的输出流 2.作用：提供字节流与字符流之间的转换 3.解码：字节、字节数组 —>字符数组、字符串 编码：字符数组、字符串 —> 字节、字节数组 4.字符集 ASCII：美国标准信息交换码。 用一个字节的7位可以表示。 ISO8859-1：拉丁码表。欧洲码表 用
转换流
hahayixiao1的博客
08-19 711
转换流 1.转换流：属于字符流 InputStreamReader：将一个字节的输入流转换为字符的输入流 OutputStreamWriter：将一个字符的输出流转换为字节的输出流 2.作用：提供字节流与字符流之间的转换 3.解码：字节、字节数组 —>字符数组、字符串 4.编码：字符数组、字符串 —> 字节、字节数组 5.字符集 ASCII：美国标准信息交换码。 用一个字节的7位可以表示。 ISO8859-1：拉丁码表。欧洲码表 用一个字节的8位表示。 GB2312：中国的中文编码表。最多
标准输入输出流打印流数据流
hahayixiao1的博客
08-19 657
标准的输入、输出流 1.1 System.in:标准的输入流，默认从键盘输入 System.out:标准的输出流，默认从控制台输出 1.2 System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。 public static void main(String[] args) { BufferedReader br = null; try { InputStreamRead
Map（1）
hahayixiao1的博客
08-14 627
一、Map的实现类的结构： Map:双列数据，存储key-value对的数据 —类似于高中的函数：y = f(x) HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。 原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。 对于频繁的遍历操作，此类执行效率高于HashMap。 TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。
conda安装BIO
最新发布
09-01
您可以使用conda安装BIO库，以下是安装的步骤： 1. 打开Anaconda Prompt或任何终端窗口。 2. 创建新的conda环境（可选）：如果您望将BIO安装在新的环境中，可以使用以下命令创建一个新的环境（名称为bio）： ```shell conda create -n bio python=3.8 ``` 这将创建一个名为`bio`的新环境，并且Python版本为3.8。您可以根据需要更改Python版本。 3. 激活环境：如果您创建了新的环境，请激活它： ```shell conda activate bio ``` 4. 安装BIO库：使用以下命令安装BIO库： ```shell conda install -c conda-forge bio ``` 这将从conda-forge通道安装BIO库及其所有依赖项。 5. 安装完成后，您可以尝试导入BIO库并使用它： ```python import bio ``` 这样就完成了BIO库的安装。请注意，如果您选择了新的conda环境，则需要在每次使用BIO库之前激活该环境。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值