BIO模型

最新推荐文章于 2023-06-20 22:03:44 发布
最新推荐文章于 2023-06-20 22:03:44 发布
阅读量334 收藏
点赞数
文章标签： java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_46097208/article/details/122158401
版权

JavaIO

4.1、IO模型

4.1.1、IO模型基本说明

  • I/O模型：就是用什么样的通道或者说是同行模式和架构进行数据的传送和接收，很大程度上决定了程序通信的性能，Java共支持3种网络编程的I/O模型:BIO、NIO、AIO
    实际通讯需求下，要根据业务场景和需求决定选择不同的I/O模型

4.2、BIO

4.2.1、BIO基本介绍

同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销

在这里插入图片描述

4.2.2、BIO工作机制

在这里插入图片描述

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

4.2.3、BIO模式下多发和多收信息

客户端


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 {
            //1.创建Socket对象请求服务端连接
            Socket s = new Socket("127.0.0.1", 666);
            //2.从socket对象获取一个字节输出流
            OutputStream os = s.getOutputStream();
            //3.把字节输出流包装成一个打印流
            PrintStream ps = new PrintStream(os);
            Scanner sc = new Scanner(System.in);
                while (true) {
                    System.out.print("请输入：");
                    String msg = sc.nextLine();
                    ps.println(msg);
                    ps.flush();
                }

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

服务器


import java.io.*;

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

/*
      目标：客户端发送消息，服务端接收消息
 */
public class Server {
    public static void main(String[] args) {
        try {
            System.out.println("--------服务端启动啦---------");
            //1.定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(666);
            //2.监听客户端的Socket请求
            Socket s = ss.accept();
            //3.从Socket通道中得到一个字节输入流对象
            InputStream is = s.getInputStream();
            //4.把字节输入缓冲流包装成一个缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine())!=null){
                System.out.println("服务端接收到:"+msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

4.2.4、BIO模式下接收多个客户端

客户端

/*
*
*      目标：实现服务端可以同时接收多个客户端的Socket通信需求
*      思路：服务端每接收到一个客户端的Socket请求对象之后都交给一个独立的线程来处理客户端的数据交互需求
*
* */

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

public class Server {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket ss = new ServerSocket(666);
            //2.定义一个死循环，负责不断的接受客户端的Socket连接请求
            while(true){
                Socket s = ss.accept();
                //3.创建一个独立的线程来处理与这个客户端的Socket通信请求
                new ServerThreadReader(s).start();
            }
        } catch (IOException e) {A
        }
    }
}

客户端创建线程类

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

public class ServerThreadReader extends Thread {
    private Socket s;
    public ServerThreadReader(Socket s){
        this.s = s;
    }
   @Override
    public void run(){
       try {
           //从Socket对象中得到一个字节输入流
           InputStream is = s.getInputStream();
           //使用缓冲字符流包装字节输入流
           BufferedReader br = new BufferedReader(new InputStreamReader(is));
           String msg;
           while ((msg=br.readLine())!=null){
               System.out.println(msg);
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

小结

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

4.3、伪异步I/O编程

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

服务端

import java.net.Socket;

/*
*    目标：开发实现伪异步通信架构
* */
public class Server {
    public static void main(String[] args) {
        try{
            //1.注册端口
            ServerSocket ss = new ServerSocket(777);
            //2.定义一个循环接收客户端的Socket请求
            //初始化一个线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(6, 16);
            while (true) {
                Socket s = ss.accept();
                //3.把Socket对象交给一个线程池进行处理，
                //把Socket封装成一个任务对象交给线程池处理
                Runnable target = new ServerRunnableTarget(s);
                pool.execute(target);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
在这里插入代码片


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

public class HandlerSocketServerPool {
    //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);
    }
}


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

public class ServerRunnableTarget implements Runnable {
    private Socket s;

    public ServerRunnableTarget(Socket s){
        this.s = s;
    }
    @Override
    public void run() {
       //处理接收到的客户端Socket通信需求
        try {
            System.out.println("--------服务端启动啦----------");
            //1.定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(666);
            //2.监听客户端的Socket请求
            Socket s = ss.accept();
            //3.从Socket通道中得到一个字节输入流对象
            InputStream is = s.getInputStream();
            //4.把字节输入缓冲流包装成一个缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            if ((msg = br.readLine())!=null){
                System.out.println("服务端接收到:"+msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

小结

  • 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但是由于底层依然是采用的同步阻塞模型，因此无法从根本上 解决问题。
  • 如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的io消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量的连接超时。
理解BIO/NIO的基本模型
05-28 351
名称的理解 BIO（Block-IO）：（同步）阻塞IO NIO（No-Block IO）: （同步）非阻塞IO AIO（asynch IO）：异步（非阻塞）IO 从标题中我们可以看出主要差异点是：阻塞/非阻塞、同步/异步 ， 理解这个问题的核心主要就在于理解：阻塞与非阻塞、同步与异步的差异究竟是什么。 PS：看的时候带着问题思考下，为什么没有ANIO（异步阻塞IO）? 阻塞与非阻塞 首先，我们先下个概述定义，阻塞非阻塞说的是线程的状态。 我们先从代码上看看关键的Blokc点，当我们申明Se
传统BIO编程模型及NIO编程模型源码
01-04
在BIO模型中，每当一个连接请求到来，服务器都会创建一个新的线程来处理这个请求，直到该请求处理完成才会释放线程。这种方式在并发量较低时可以正常工作，但当并发量增大时，服务器会创建大量线程，导致内存消耗...
网络编程之中篇——BIO模型详述
m0_54356563的博客
10-09 1301
1、BIO介绍 1.1、BIO的概念 BIO（Blocking IO）同步阻塞IO模型，在JDK 1.4之前，建立网络链接采用的只有BIO的模型 需要服务端首先启动建立一个ServerSocket实例，然后客户端启动Socket实例对服务端进行连接通信，服务端通过调用accept方法等待接收客户端的连接请求，一旦接收到连接请求，就可以进行读写操作 在BIO编程中，相应的方法会产生阻塞：accept()、read()、write()、connect(),直至相关的操作等待完成之后才能继续后续代..
BIO模型(Blocking IO)
qq_41931364的博客
12-25 1817
BIO模型（Blocking IO）1、什么是BIO模型？2、BIO的单线程模式2.1、服务端2.2、客户端测试3、BIO多线程模式3.1、多线程服务端代码3.2、客户端测试4、客户端代码示例5、总结5.1、BIO模型的优势5.2、BIO模型的缺点 1、什么是BIO模型？ BIO模型，也叫阻塞式IO模型，在客户端与服务端建立连接时会阻塞，在服务端等待客户端发消息时也会阻塞。 2、BIO的单线程模式 2.1、服务端 大概解释一下下面这些代码。 1、首先服务端在启动时创建一个Socket连接并使得9000
服务端的bio 模型
01-09
bio模型，每个客户端连接必须要有一个连接与之对应，性能较低
从连接器组件看Tomcat的线程模型——BIO模式(推荐)
01-09
在深入探讨Tomcat的BIO（Blocking I/O）线程模型之前，首先需要理解什么是BIO模式。BIO，即阻塞I/O模式，是一种传统的I/O处理方式，当一个线程等待数据读取或写入时，该线程会被阻塞，直到I/O操作完成。这种模式在...
基于java的BIO、NIO、AIO通讯模型代码实现
03-24
在BIO模型中，每个连接都需要一个独立的线程来处理，当客户端请求到达时，服务器会为每个请求创建一个新的线程。这种方式在客户端数量较少时可以正常工作，但如果并发连接数增多，服务器将面临线程创建和管理的开销...
Java通讯模型-BIO、NIO、AIO综合演练
05-04
NULL 博文链接：https://bijian1013.iteye.com/blog/2433654
Java IO模型之BIO模型
guohao_Kwok的博客
01-05 817
【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> ...
BIO网络模型
Hern（宋兆恒）
09-26 623
BIO（同步阻塞） 在JDK1.4出来之前，建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或者遭到拒绝请求，如果有的话，客户端会线程会等待请求结束后才继续执行。 同步并阻塞，服务器实现模式为一...
Java通信---（一）bio模型
as18819281938的博客
02-14 325
 1.同步和异步一般指的是io操作。阻塞和非阻塞是指线程。    同步是用户进程在触发io操作并等待，轮询的去查看io操作是否就绪。异步是触发io操作之后还能进行其他操作，当io操作完成之后也能得到通知。   阻塞是线程在得到调用结果之前一直等待。非阻塞是线程在执行完数据之后被挂起，等待下次被唤醒。2.bio 也叫做同步阻塞型io。   处理步骤： 客户端发送请求，接收器Acceptor每接收一个...
IO模型之BIO模型（Netty一）
qq_36594703的博客
08-29 266
1.Netty是一个异步的，基于事件驱动的网络应用框架，用以快速开发高性能、高可靠的网络IO程序，netty主要针对在TCP协议下，面向clients端的高并发应用或者Peer To Peer场景下的大量数据传输应用，netty本质是一个NIO框架，适用于服务器通讯的相关的多种应用场景。 2.IO模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。 3.Java共支持3种网络编程模型IO模式：BIO,NIO,AIO 4.BIO（同步并阻塞）：服务器实现模式为一个连接
BIO模型分析
weixin_34101229的博客
08-01 210
为什么80%的码农都做不了架构师？>>> ...
Java中的BIO通信模型
程铭程铭你快成名的博客
08-10 7789
在上一篇Linux和Java中的I/O模型中介绍了NIO、BIO模型，本篇文章讲解一下多线程+BIO的通信模型。主流的web服务器Tomcat就是多线程+BIO的通信模型的代表者。 原理图 Server端 Server端即接收消息的那一端。BIO是一种阻塞IO，也就是说，当前线程会一直阻塞，直到接受到消息。所以通常会使用多个线程来配合，即每来一个IO连接，都新启一个线程去处理。 但由于在Java中，线程是一种比较宝贵的资源，所以一般会使用线程池来复用线程资源。 public class Server {
BIO、NIO线程模型
最新发布
crazy_xieyi的博客
06-20 956
本文主要介绍了BIO（单线程、多线程和线程池版本）和NIO（早期版本和多路复用器版本）两种线程模型。
Java基础知识——BIO模式
weixin_46025531的博客
01-25 3031
文章目录一、Java的I/O总述1、I/O模型2、应用二、BIO模式1、传统的服务器、客户端通信(一对一)：2、服务器和客户端的通信(一对多) 一、Java的I/O总述 I/O模型：就是用什么样的通道或者通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能，包括BIO、NIO、AIO 1、I/O模型 BIO： 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即用户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情就会造成不必要的线程开销 NIO： 同步非阻
深入浅出：BIO与NIO编程模型源码分析
BIO模型是一种传统的I/O模型，其中的关键在于每一个客户端连接都需要一个线程去处理。在BIO模型中，客户端发起一个连接请求，服务器端通过阻塞调用accept()来监听连接请求。一旦接收到一个连接请求，服务器就会为该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值