BIO同步阻塞式IO通信

于 2023-08-10 21:55:21 发布
阅读量153 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51240148/article/details/132218567
版权

文章目录

I/O 模型基本说明

I/O 模型：就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能，Java 共支持 3 种网络编程的/IO 模型：BIO、NIO、AIO

Java BIO

  • BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器).
    简单示意图：
    在这里插入图片描述

Java BIO 工作机制

在这里插入图片描述

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

BIO模式下接收单客户端

客户端代码如下：

/**
    目标: Socket网络编程。

    功能1：客户端可以反复发消息，服务端可以反复收消息

    小结：
        通信是很严格的，对方怎么发你就怎么收，对方发多少你就只能收多少！！

 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // （1）创建一个Socket的通信管道，请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",8888);
        // （2）从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // （3）把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);//这行代码将字节输出流转换为PrintStream对象。PrintStream类提供了方便的方法，可以将数据以字符串形式打印到输出流中。
        // （4）开始发送消息
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.print("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

服务端代码:

/**
 * 服务端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {    
        System.out.println("==服务器的启动==");
        //（1）注册端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //（2）开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
        Socket socket = serverSocket.accept();
        //（3）从Socket管道中得到一个字节输入流。
        InputStream is = socket.getInputStream();
        //（4）把字节输入流包装成自己需要的流进行数据的读取(字符流)。
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        //（5）读取数据
        String line ;
        while((line = br.readLine())!=null){
            System.out.println("服务端收到："+line);
        }
    }
}

小结:实现单客户端多发，服务端只能处理一个客户端的请求，因为服务端是单线程的。一次只能与一个客户端进行消息通信。

BIO模式下接收多客户端

客户端代码如下：

/**
    目标: Socket网络编程。

    功能1：客户端可以反复发，一个服务端可以接收无数个客户端的消息！！

    小结：
         服务器如果想要接收多个客户端，那么必须引入线程，一个客户端一个线程处理！！

 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==客户端的启动==");
        // （1）创建一个Socket的通信管道，请求与服务端的端口连接。
        Socket socket = new Socket("127.0.0.1",7777);
        // （2）从Socket通信管道中得到一个字节输出流。
        OutputStream os = socket.getOutputStream();
        // （3）把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        // （4）开始发送消息
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.print("请说:");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

服务端代码:

/**
    服务端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("==服务器的启动==");
        // （1）注册端口
        ServerSocket serverSocket = new ServerSocket(7777);
        while(true){
            //（2）开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
            Socket socket = serverSocket.accept();
            new ServerReadThread(socket).start();
            System.out.println(socket.getRemoteSocketAddress()+"上线了！");
        }
    }
}

class ServerReadThread extends Thread{
    private Socket socket;

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

    @Override
    public void run() {
        try{
            //（3）从Socket管道中得到一个字节输入流。
            InputStream is = socket.getInputStream();
            //（4）把字节输入流包装成自己需要的流进行数据的读取。
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //（5）读取数据
            String line ;
            while((line = br.readLine())!=null){
                System.out.println("服务端收到："+socket.getRemoteSocketAddress()+":"+line);
            }
        }catch (Exception e){
            System.out.println(socket.getRemoteSocketAddress()+"下线了！");
        }
    }
}

小结:

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

伪异步I/O编程

概述

在上述案例中：客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

​采用一个伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。
在这里插入图片描述

客户端代码如下：

public class Client {
   public static void main(String[] args) {
      try {
         // 1.建立一个与服务端的Socket对象：套接字
         Socket socket = new Socket("127.0.0.1", 9999);
         // 2.从socket管道中获取一个输出流，写数据给服务端 
         OutputStream os = socket.getOutputStream() ;
         // 3.把输出流包装成一个打印流 
         PrintWriter pw = new PrintWriter(os);
         // 4.反复接收用户的输入 
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         String line = null ;
         while((line = br.readLine()) != null){
            pw.println(line);
            pw.flush();
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

线程池代码：

// 线程池处理类
public class HandlerSocketThreadPool {
   
   // 线程池 
   private ExecutorService executor;
   
   public HandlerSocketThreadPool(int maxPoolSize, int queueSize){
      
      this.executor = new ThreadPoolExecutor(
            3, // 8
            maxPoolSize,  
            120L, 
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(queueSize) );
   }
   
   public void execute(Runnable task){
      this.executor.execute(task);
   }
}

服务端代码:

public class Server {
   public static void main(String[] args) {
      try {
         System.out.println("----------服务端启动成功------------");
         ServerSocket ss = new ServerSocket(9999);

         // 一个服务端只需要对应一个线程池
         HandlerSocketThreadPool handlerSocketThreadPool =
               new HandlerSocketThreadPool(3, 1000);

         // 客户端可能有很多个
         while(true){
            Socket socket = ss.accept() ; // 阻塞式的！
            System.out.println("有人上线了！！");
            // 每次收到一个客户端的socket请求，都需要为这个客户端分配一个
            // 独立的线程 专门负责对这个客户端的通信！！
            handlerSocketThreadPool.execute(new ReaderClientRunnable(socket));
         }

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

}
class ReaderClientRunnable implements Runnable{

   private Socket socket ;

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

   @Override
   public void run() {
      try {
         // 读取一行数据
         InputStream is = socket.getInputStream() ;
         // 转成一个缓冲字符流
         Reader fr = new InputStreamReader(is);
         BufferedReader br = new BufferedReader(fr);
         // 一行一行的读取数据
         String line = null ;
         while((line = br.readLine())!=null){ // 阻塞式的！！
            System.out.println("服务端收到了数据："+line);
         }
      } catch (Exception e) {
         System.out.println("有人下线了");
      }

   }
}

小结:

  • 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根本上解决问题。
  • 如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。
ITfeib
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java BIO - 阻塞式IO详解
qq_43336324的博客
09-21 701
文章目录重要概念传统的BIO通信方式传统的BIO的问题多线程方式 - 伪异步方式BIO通信方式深入分析 重要概念 阻塞和同步，非阻塞和异步，这两组词的关联度是很高的，是不能分开讲的,像多线程并发往往也会论述这些概念。下面会从IO的角度切入。 阻塞IO 和 非阻塞IO 这两个概念是程序（进程线程）级别的。主要描述的是程序请求操作系统IO操作后，如果IO资源没有准备好，那么程序该如何处理的问题: 前者等待；后者继续执行(并且使用线程一直轮询，直到有IO资源准备好了) 同步IO 和 非同步IO 这两个
【Socket学习】2. BIO（阻塞IO）
hmmm？
01-17 604
【Socket学习】2. BIO（阻塞IO） 普通的IO之前看了，就没写博客儿了，那都不是这个重点 这次重点写的是BIO（Blocking IO) 2.1 BIO的一系列操作 应用程序向操作系统请求网络IO操作，这时应用程序就会进入阻塞状态，开始等待。 操作系统收到请求后，也会等待，直到网络上有数据传到监听端口； 操作系统在收到数据后，会把数据发送给应用程序； 最后应用程序收到数据就会解除阻塞状态。 2.2 一些重要概念 阻塞IO 和 非阻塞IO 这两个词是用于描述应用程序的。前者阻塞I
Java网络编程——BIO阻塞IO
点滴汇聚，智在积累。——Danny
08-03 707
但又带来了新的问题：每接收一个客户端就用一个线程去处理，如果创建的线程过多，会消耗大量的服务器资源，即使用线程池的方式来限制线程数量和上下文切换，如果多个客户端连接成功后都等待，也会导致服务端的线程都阻塞，治标不治本。BIO（Blocking IO）也就是阻塞IO，当服务端和客户端交互时，如果服务端接收了一个客户端请求，就要为这个客户端一直服务直到结束，否则无法为下一个客户端服务。BIO的“阻塞”就体现在这里，当一个服务端线程正在处理或者等待处理某个客户端的请求，是无法为其他客户端服务的。...
Netty学习之BIO(阻塞IO)
Crazer_cy的博客
08-25 585
传统的IO传输，服务端会一直等待客户端传来数据，不能做其他事，便处于阻塞状态，即阻塞IO。 通过把一个文件从客户端传输到服务端的案例来理解一下BIO： 首先是客户端的代码： @Test public void client(){ try { //1.获取通道 SocketChannel clientChan
BIO-(阻塞式 I/O 模型(blocking I/O）)
a547195893的博客
11-19 817
BIO 线程模型 BIO I/O模型 阻塞非阻塞定义 阻塞和非阻塞指的是调用者（程序）在等待返回结果（或输入）时的状态。 阻塞时，在调用结果返回前，当前线程会被挂起，并在得到结果之后返回。 非阻塞时，如果不能立刻得到结果，则该调用者不会阻塞当前线程。因此对应非阻塞的情况，调用者需要定时轮询查看处理状态。 – 百度百科 简单的说就是b被a调用 b在响应结果给a回复之前,a是否一直在等着,如果a等着则就可以说是阻塞的 同步处理与异步处理 同步处理是指被调用方得到最终结果之后才返回给调用方； 异步处理是
基于BIO的Java Socket通信详解
08-28
BIO指的是阻塞IO，在基于Socket的消息通信过程中，Socket服务端向外部提供服务，而Socket客户端可以建立到Socket服务端的连接，进而发送请求数据，然后等待Socket服务端处理，并返回处理结果（响应）。 在基于BIO的...
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
最新发布
01-04
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析 IO模型在计算机编程中扮演着至关重要的角色，特别是在网络通信中。Java提供了三种主要的IO模型：BIO（Blocking IO），NIO（Non-blocking IO），...
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
BIO 是传统的同步阻塞模型，服务器端使用 ServerSocket 监听客户端的连接请求，客户端使用 Socket 向服务器端发送连接请求。如果连接成功建立，双方就可以通过套接字进行通信。 BIO 的服务端通信模型可以简单地描述...
JAVA IO的3种类型区别解析
08-25
BIO是传统的IO模型，它是一种同步阻塞的IO方式。在JDK 1.4之前，BIO是主要的网络通信方式。在BIO模式下，服务端需要为每个客户端请求创建一个新的线程来处理，客户端也需要等待服务端的响应才能继续执行。例如，当...
Java IO应届生培训讲义
09-08
Java BIO即传统的Java IO，采用同步阻塞模式，适用于连接数量不多且固定的场景。BIO中的流是阻塞的，即当一个线程调用read()或write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程才能继续执行。 7. Java...
25 网络编程高级(同步、异步、NIO、BIO、AIO)
08-07
教程视频：网络编程高级(同步、异步、NIO、BIO、AIO)。
BIO(阻塞IO模型)+Socket網絡通信
Bai_xing_yu的博客
03-25 352
創建服務端 import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class BIOServerSocket { public static void main(String[] args) throws IOException { Server...
IO模型2-BIO(阻塞IO模型)
qq_15740267的博客
11-02 138
【代码】IO模型2-BIO(阻塞IO模型)
Java IO : BIO阻塞模型
OneFine的技术博客
08-23 225
1
BIO编程（同步阻塞IO）
sspudding
06-04 787
BIO即 Blocking IO，是同步阻塞的编程方式，BIO 编程方式通常是在JDK1.4 版本之前常用的编程方式。 BIO服务端通信模型图： 图源网络，侵删 采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理，处理完成之后，通过输出流返回应答给客户端，线程销毁。这就是典型的一请求一应答通信模...
UNIX网络模型
admin3335的博客
10-19 610
UNIX网络模型
同步阻塞IO（BIO）原理与代码样例 
qq_33642970的博客
04-20 300
同步阻塞IO（BIO）顾名思义就是指的发起一个请求到服务器后；等待服务器处理该请求处理结束后再进行后续处理；在服务器处理的过程中；客户端处于阻塞状态；例如；张三找领导李四签字；张三把文件交给李四后；李四签字；在李四签字的时候张三处理等待状态；不做任何其他的事情；（处于阻塞状态）；李四签字结束后；文件还给张三；张三结束等待状态；出去开始做其他事情。 因此；BI...
01BIO-同步并阻塞IO的讲解
TT的博客
06-05 256
简介 BIO(Blocking IO):同步并阻塞IO，最为传统的通讯模式，意味着一个连接就有一个线程，比如服务器启动好了，我们3个人要去连接服务器，我们就是客户端，我们没连接进去一个人，服务端就会单独给我们启动一个线程，这样有坏处，就是如果我们连接进去啥也不做，线程一直在那边挂着，会造成一种资源浪费的情况，虽然后续有一些基于现模式的处理方式，但是还有有一些不可忽略的缺陷。 案例 案例一：简单的通讯方式(基于TCP连接) 代码略… 代码省略的原因是这个很简单，不管你是学校，还是培训机构学的，还是网上自学，最
网络编程之BIO（同步阻塞）
weixin_45239670的博客
04-27 389
1.服务端 package com.io.bio2; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import static java.util.concurrent.Executors.newCachedThreadPool; /** * @author yangmin * @version
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值