BIO 同步阻塞模型

最新推荐文章于 2023-04-26 11:52:17 发布
最新推荐文章于 2023-04-26 11:52:17 发布
阅读量233 收藏
点赞数
分类专栏： netty 与IO编程 文章标签： BIO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36654629/article/details/112193994
版权

在这里插入图片描述
干饭人，干饭魂，了解了BIO的都是人上人。。。。

有时候就感觉很奇怪，在我大学的时候，学这种IO编程总是学得不明不白。但是现在呢？一触即会。哈哈，我jio得我可能天赋异禀~
在这里插入图片描述

Java BIO 基本介绍

Java BIO 同步阻塞模型，属于传统的 java io 编程，其相关的类和接口在 java.io包下。

服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器).

BIO工作机制

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

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

这里，编写一些简单的案例便于理解。

BIO编程实例

网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信（绑定IP地址和端口），客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下进行三次握手连接，连接成功后，双方通过网络套接字（Socket）进行通信。

功能1：客户端发送一个消息，服务端接口一个消息，通信结束！！

创建客户端对象：
（1）创建一个Socket的通信管道，请求与服务端的端口连接。
（2）从Socket管道中得到一个字节输出流。
（3）把字节流改装成自己需要的流进行数据的发送

客户端代码

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

/**
 目标: Socket网络编程。
 Java提供了一个包：java.net下的类都是用于网络通信。
 Java提供了基于套接字（端口）Socket的网络通信模式，我们基于这种模式就可以直接实现TCP通信。
 只要用Socket通信，那么就是基于TCP可靠传输通信。

 Socket的使用：
 构造器：public Socket(String host, int port)
 方法：  public OutputStream getOutputStream()：获取字节输出流
 public InputStream getInputStream() :获取字节输入流

 ServerSocket的使用：
 构造器：public ServerSocket(int port)
 小结：
 通信是很严格的，对方怎么发你就怎么收，对方发多少你就只能收多少！！
 */
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 os = socket.getOutputStream();
        //把字节流改装成自己需要的流进行数据发送
        PrintStream ps = new PrintStream(os);

        ps.println("hi,我是客户端端，我给你发消息了！！");
        ps.flush();

    }
}

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

服务端代码

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

/**
 * @PackageName: com.netty.bio.demo1
 * @author: youjp
 * @create: 2020-12-18 10:59
 * @description: 服务端案例
 * @Version: 1.0
 */
public class ServerDemo {

    public static void main(String[] args) throws IOException {

        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 ;
        if ((line = br.readLine())!=null){
            System.out.println("服务端收到："+line);
        }

    }
}

启动测试，注意先启动服务端，再启动客户端，不然客户端会报错。

功能2：在功能1的基础上实现消息的多发和多收

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

客户端代码如下

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
 目标: Socket网络编程。
	功能2： 客户端可以反复发，一个服务可以接收无数个客户端消息！！
 小结：服务器如果想要接收多个客户端，那么必须引入线程，一个客户端一个线程处理！！
 */
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 os = socket.getOutputStream();
        InputStream in=socket.getInputStream();
        //把字节流改装成自己需要的流进行数据发送
        PrintStream ps = new PrintStream(os);

        Scanner scanner=new Scanner(System.in);
        while (true){

            System.out.print("请说:");
            String str=scanner.nextLine();
            ps.println(str);
            ps.flush();
        }

    }
}

服务端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @PackageName: com.netty.bio.demo1
* @author: youjp
* @create: 2020-12-18 10:59
* @description: 服务端案例
* @Version: 1.0
*/
public class ServerDemo {
    public static void main(String[] args) throws IOException {
        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);
        }
    }
}

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

功能3：使用线程池来接收多个客户端

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

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.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* @PackageName: com.netty.bio.demo3
* @author: youjp
* @create: 2020-12-20 17:23
* @description:
* @Version: 1.0
*/
public class ServerDemo {

    public static void main(String[] args) throws IOException {

        ExecutorService service= Executors.newCachedThreadPool(); //弹性伸缩线程池
        System.out.println("服务启动----------");
        ServerSocket serverSocket=new ServerSocket(8889);

        while(true){
     		  final  Socket socket= serverSocket.accept();
             service.submit(new MyThread(socket));//
        }
    }
}

class MyThread implements Runnable{

    private Socket socket;
    public MyThread(Socket socket){
        this.socket=socket;
    }

    @Override
    public void run() {
        execute();
    }
    
    public void execute(){
        System.out.println("分配到线程---"+Thread.currentThread().getName()+"---------------");
        //（3）从Socket管道中得到一个字节输入流。
        InputStream is = null;
        try {
            is = socket.getInputStream();
            //（4）把字节输入流包装成自己需要的流进行数据的读取。
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            //（5）读取数据
            String line ;
            while ((line = br.readLine())!=null){
                System.out.print("通过执行线程，--名称---"+Thread.currentThread().getName()+"---------------");
                System.out.println("服务端收到："+line);
            }

        } catch (IOException e) {
            System.out.println(Thread.currentThread().getName()+"断开连接");
            //e.printStackTrace();
        }
    }
}

客户端

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
 目标: Socket网络编程。
实现：运行多个客户端，向服务端发送消息
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 os = socket.getOutputStream();
        //把字节流改装成自己需要的流进行数据发送
        PrintStream ps = new PrintStream(os);

        Scanner scanner=new Scanner(System.in);
        while (true){
            System.out.print("请说:");
            String str=scanner.nextLine();
            ps.println(str);
            ps.flush();
        }

    }
}

本案例你会发现，每单有客户端对服务端发起连接时，服务端就会创建一个线程进行处理。

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

有兴趣的老爷，可以关注我的公众号【一起收破烂】，回复【006】获取2021最新java面试资料以及简历模型120套哦~
在这里插入图片描述

收破烂的小熊猫~
关注
专栏目录
同步阻塞式I/O模型
西瓜游侠的博客
11-10 493
参考：《Netty权威指南》 同步阻塞式I/O，即BIO。 原理：服务器端通常由一个独立的Acceptor负责监听客户端的连接，它接收到客户端请求之后为每个请求创建一个新的线程进行链路处理，处理完成通过输出流返回应答给客户端，并销毁线程。是典型的 一请求一应答 模型。 缺点：缺乏弹性，当并发访问量增加，由于大量的开辟线程导致系统性能急剧下降，系统可能发生线程堆栈溢出、创建新线程失败
IO通信模型（一）同步阻塞模式BIO（Blocking IO）
weixin_30701575的博客
10-23 176
几个概念 阻塞IO 和非阻塞IO 这两个概念是程序级别的。主要描述的是程序请求操作系统IO操作后，如果IO资源没有准备好，那么程序该如何处理的问题：前者等待；后者继续执行（但是使用线程一直轮询，直到有IO资源准备好了）。 同步IO 和 异步IO，这两个概念是操作系统级别的。主要描述的是操作系统在收到程序请求IO操作后，如果IO资源没有准备好，该如何响应程序的问题：前者不响应，直到IO资源准备好以后...
JAVA BIO深入剖析（二）
名字好难想
02-01 181
Java BIO 基本介绍 Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需 要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器). 2 Java BIO 工作机制 1) 服务器端启动一个 ServerSocket，注册端口，调用accpet方法监听客户端的Socket连接。 2)
同步阻塞IO模型
北漂码农有话说
12-08 146
同步阻塞IO模型 有上篇IO模型中的，同步阻塞IO模型，我们能够知道，用户线程发起请求后就一直阻塞的等待 内核完成准备数据、数据拷贝的工作。并且返回成功的指示。 实现 使用java来实现同步阻塞IO模型，即我们所说的BIO的模型 客户端实现 /** * @author:triumphxx * @Date:2021/10/12 * @Time:10:29 下午 * @微信公众号：北漂码农有话说 * @
Windows IO模型-Select模型（同步阻塞模型）
xiaobangkuaipao的博客
09-07 1692
参考博客：http://zxxapple.iteye.com/blog/1554692    套接字Select 阻塞和非阻塞的区别在于：进程访问数据时，数据未就绪，进行是否需要等待。阻塞：进程等到有结果再返回，函数返回。非阻塞：请求完立即返回，不论是否接收到数据。 异步和同步的区别在于：主动查看还是被动通知的区别，访问数据的机制不同。同步：主动请求，并等待I\O操作完毕，当数据读写时阻塞。异
Java中IO模型之BIO（同步阻塞模型）
ccuaman的博客
07-21 726
Java中IO模型之BIO（同步阻塞模型） BIO：同步阻塞模型 在JDK1.4之前，建立网络通信采用的BIO模型 需要现在服务器启动一个ServerSocket，然后客户端启动一个Socket来对服务端进行连接，默认的情况下服务端需要对每一个请求建立一个线程等待处理，客户端发送请求后，需要等待服务端是否有相应的线程来处理客户端的连接，如果没有线程则会一致等待或者拒绝请求，如果有的话，客户端会等待线程来处理客户端请求 在了解BIO模型之前先让我们回顾一下Socket通信流程 基于BIO的编程 通过网络通信
网络-java中BIO(同步阻塞模型)的理解与应用
Fly_Fly_Zhang的博客
05-22 970
BIO通信模型 BIO通信服务端，通常有一个独立的Acceptor线程负责监听客户端的连接。接收到客户端连接请求后会为每个客户创建一个新的线程进行链路处理，处理完成后返回应答给客户端，也就是经典的请求-应答 通信模型。 但是随着客户端并发数量上升，服务端的线程膨胀，系统性能急剧下降，最终会导致系统不可用。 缺点： 无法满足高并发，高性能的场景。因为它每一个连接就会创建一个新的线程，而创建线程是...
JavaIO四大模型：BIO(同步阻塞IO)
Colorful_X的博客
06-04 256
文章目录IO读写原理Java I/O底层流程四大模型之：BIO同步阻塞IO IO读写原理         用户进程进行的IO读写，都会用到read和write两大系统调用。         read系统调用：将数据从内核缓冲区复制到进程缓冲区中。         wri
详解 同步异步、阻塞非阻塞 与 BIO NIO AIO区别、多路复用
Java技术攻略的博客
03-06 410
BIO（同步阻塞）：你到饭馆点餐，然后在那等着，啥都干不了，餐没做好，你就必须等着！NIO（同步非阻塞）：你在饭馆点完餐，就去玩儿了。不过玩一会儿，就回饭馆问一声：好了没？AIO（异步非阻塞）：饭馆打电话说，我们知道您的位置，一会给你送过来，安心玩儿就可以了，类似于外卖。哪种方式更有效率呢？是不是一目了然呢？BIO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
网络编程之BIO（同步阻塞）
weixin_45239670的博客
04-27 392
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
五种IO模型：同步阻塞I/O、同步非阻塞I/O、同步I/O复用模型、同步信号驱动I/O、异步I/O模型
CLZHIT的博客
03-18 1046
阻塞、非阻塞、多路IO复用，都是同步IO，异步必定是非阻塞的，所以不存在异步阻塞和异步非阻塞的说法。换句话说，只有用户线程在操作IO的时候根本不去考虑IO的执行，全部都交给CPU去完成，而自己只等待一个完成信号的时候，才是真正的异步IO。异步过程中进程触发IO操作以后，直接返回，做自己的事情，IO交给内核来处理，完成后内核通知进程IO完成。同步：执行一个操作之后，进程触发IO操作并等待(也就是我们说的阻塞)或者轮询的去查看IO操作(也就是我们说的非阻塞)是否完成，等待结果，然后才继续执行后续的操作。
2、Java BIO
Yisnow.的博客
10-12 192
1、IO模型 IO模型：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能； Java支持3种网络编程模式：BIO NIO AIO Java BIO 同步并阻塞（传统阻塞型）：服务器实现模式是一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个线程不做任何事情会造成不必要的线程开销； Java NIO 同步非阻塞。服务器实现模式为一个线程处理多个请求，客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理。 Ja
Netty原理分析及实战（一）-同步阻塞模型（BIO）
专注基础架构领域
06-03 826
刚入OPEN AI LAB的时候，了解到公司主要是做人工智能和物联网的公司，Netty在作为物联网这块有很大的优势，之前就对Netty框架非常感兴趣，所以趁着这个机会，就多了解了一些Netty的内容，我在这里通过文章的方式分享给大家，为什么我要从BIO开始讲，因为Netty本身是基于NIO来进行架构的，而NIO又是起源于BIO，所以我索性就从最原始的BIO开始讲解，这样可以让大家理解深刻一些。 ...
Linux五种IO模型(同步 阻塞概念)
04-20 155
Linux五种IO模型 同步和异步 这两个概念与消息的通知机制有关。 同步 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。比如，调用readfrom系统调用时，必须等待IO操作完成才返回。 异步 异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。比如：调用aio_...
BIO编程（同步阻塞IO）
sspudding
06-04 790
BIO即 Blocking IO，是同步阻塞的编程方式，BIO 编程方式通常是在JDK1.4 版本之前常用的编程方式。 BIO服务端通信模型图： 图源网络，侵删 采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理，处理完成之后，通过输出流返回应答给客户端，线程销毁。这就是典型的一请求一应答通信模...
BIO -- 同步阻塞的编程方式
Daria_的博客
06-18 340
BIO编程方式通常是在JDK1.4版本之前常用的编程方式 一、编程实现的过程：   先在服务端启动一个ServerSocket来监听网络请求，客户端启动Socket发起网络请求，默认情况下ServerSocket会建立一个线程来处理此请求，如果服务端没有线程可用，客户端则会阻塞等待或者遭到拒绝，并且建立好的连接，在通信过程中是同步的，在并发处理上效率较低；   同步并阻塞，服务器实现模式为一个连...
关于BIO同步阻塞,NIO同步非阻塞,AIO异步非阻塞,多路复用
FREEDOM
06-16 919
前言 使用异步，非阻塞。是为了减少线程的开销（因为正常情况下一个IO如一个socket客户端的连接，server需要单独开一个线程，传统的socket是同步阻塞的） （1）同步/异步 ：内核缓冲区 向用户缓冲区 态写数据的过程，如果这个过程 中， 用户线程不阻塞就是异步，阻塞就是同步。 （2）阻塞/非阻塞 ： 用户线程 是否一直等待内核缓冲区有数据，有数据才会返回的为阻塞。不管有没有数据都返回的叫做非阻塞。 1.1. JavaIO读写原理 无论是Socket的读写还是文件的读写，在Ja....
同步-异步-阻塞-非阻塞，IO模型浅析(包括同步阻塞IO，同步非阻塞IO，IO多路复用，异步IO)
热门推荐
scoful的专栏
04-07 2万+
转载 服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种：（1）同步阻塞IO（Blocking IO）：即传统的IO模型。（2）同步非阻塞IO（Non-blocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（New IO）库。（3）IO多路复用（IO&nbsp...
Java BIO(Blocking IO:同步并阻塞式IO)
最新发布
xp_xpxp的博客
04-26 478
Java BIO相关知识
gRPC线程模型：从BIO到高性能优化
同时，由于I/O操作是同步阻塞的，当某个连接出现延迟时，整个线程会被阻塞，影响服务的稳定性和可靠性。此外，过多的线程也会增加系统的维护难度。 为了解决这些问题，出现了线程池优化的BIO模型。在这种模型中，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

收破烂的小熊猫~

你的鼓励将是我创造最大的东西~

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

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

打赏作者

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

抵扣说明：

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

余额充值