二、JAVA BIO

最新推荐文章于 2024-04-29 19:18:22 发布
最新推荐文章于 2024-04-29 19:18:22 发布
阅读量2.2k 收藏 5
点赞数
分类专栏： # 网络编程与IO 文章标签： BIO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/124067106
版权

NIO 目录

文章目录

二、JAVA BIO

1、 Java BIO基本介绍

Java BlO就是传统的Java IO编程，其相关的类和接口在Java.io 包中。

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

2、 java BIO工作机制

3、传统的BIO编程实例回顾

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

传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址，启动监听端口；客户端Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。

基于BIO模式下的通信，客户端-服务端是完全同步，完全藕合的。

3.1、客户端案例如下

package 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 socket = new Socket("127.0.0.1", 9999);
            //2、从socket对象中获取一个输出流
            OutputStream out = socket.getOutputStream();
            //3、把字节输出流包装成打印流
            PrintStream printStream = new PrintStream(out);
            printStream.println("hello World! 服务端，你好");
            printStream.flush();

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

3.2、服务端案例如下

package bio;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 目标：客户端发送消息，服务端接收消息
 */
public class Server {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动===");
            //1、对服务端端口进行注册 9999
            ServerSocket serverSocket = new ServerSocket(9999);
            //2、监听客户端socket请求
            Socket socket = serverSocket.accept();
            //3、从socket管道中得到一个字节输入流对象
            InputStream is = socket.getInputStream();
            //4、将字节输入流包装成一个缓冲字符输入流，提高效率
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            /*while ((msg = br.readLine()) != null){
                System.out.println("服务端接收到:"+msg);
            }*/
            if ((msg = br.readLine()) != null){
				System.out.println("服务端接收到：" + msg);
			}
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.3、输出

===服务端启动===
服务端接收到：hello World! 服务端，你好

3.4、小结

在以上通信中，服务端会一直等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直进入阻塞状态。

同时服务端是按照行获取消息的，这意味着客户端也必须按照行进行消息的发送，否则服务端将进入等待消息的阻塞状态！

4、BIO模式下多发和多收消息

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

4.1、客户端代码如下

package 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 socket = new Socket("127.0.0.1",9999);
            //2、从socket对象中获取一个输出流
            OutputStream out = socket.getOutputStream();
            //3、把字节输出流包装成打印流
            PrintStream printStream = new PrintStream(out);
            Scanner sc = new Scanner(System.in);
            while (true){
                System.out.print("请说：");
                String msg = sc.nextLine();
                printStream.println(msg);
            	printStream.flush();
            }

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

4.2、服务端代码如下

package bio;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 目标：服务端可以反复的接收消息，客户端可以反复的发送消息
 */
public class Server {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动===");
            //1、对服务端端口进行注册 9999
            ServerSocket serverSocket = new ServerSocket(9999);
            //2、监听客户端socket请求
            Socket socket = serverSocket.accept();
            //3、从socket管道中得到一个字节输入流对象
            InputStream is = socket.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.3、输出

客户端：
请说：hello
请说：what are you doing?
请说：
    
    
服务端：
===服务端启动===
服务端接收到：hello
服务端接收到：what are you doing?

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

5.1、概述

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

图解模式如下：

1-1

5.2、客户端案例代码

package 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 socket = new Socket("127.0.0.1",9999);
            //2、从socket对象中获取一个输出流
            OutputStream out = socket.getOutputStream();
            //3、把字节输出流包装成打印流
            PrintStream printStream = new PrintStream(out);
            Scanner sc = new Scanner(System.in);
            while (true){
                System.out.print("请说：");
                String msg = sc.nextLine();
                printStream.println(msg);
            	printStream.flush();
            }

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

5.3、服务端案例代码

package bio;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * 目标：服务端可以实现同时接收多个客户端的Socket通信需求
 * 思路：服务端每接收到一个客户端socket请求对象之后都交给一个独立的线程来处理客户端的数据交互需求
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket ss = new ServerSocket(9999);
            //2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
            while(true){
            	Socket socket = ss.accept();
                
            	//3.创建一个独立的线程来处理与这个客户端的socket通信需求
            	new ServerThreadReader(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.4、线程类

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

5.5、输出

===client1:
请说：
ppp
请说：
你在干嘛？
请说：
我是第一个client
请说：
    
===client2:
请说：
lll
请说：
还钱！！！
请说：
我是第二个client
请说：
    
===client3:
请说：
我是第三个client
请说：
    
===server:
lll
ppp
你在干嘛？
还钱！！！
我是第二个client
我是第一个client
我是第三个client

5.6、小结

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

6、伪异步I/O编程

6.1、概述

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

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

如下图所示：

6.2、客户端案例代码

package 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 socket = new Socket("127.0.0.1",9999);
            //2、从socket对象中获取一个输出流
            OutputStream out = socket.getOutputStream();
            //3、把字节输出流包装成打印流
            PrintStream printStream = new PrintStream(out);
            Scanner sc = new Scanner(System.in);
            while (true){
                System.out.print("请说：");
                String msg = sc.nextLine();
                printStream.println(msg);
            	printStream.flush();
            }

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

6.3、服务端案例代码

package bio;

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.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 目标：开发实现伪异步通讯架构
 * 思路：服务端没接收到一个客户端socket请求对象之后都交给一个独立的线程来处理客户端的数据交互需求
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.注册端口
            ServerSocket ss = new ServerSocket(9999);
            //2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
            //初始化一个线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(3,10);
            while(true){
            	Socket socket = ss.accept();
                
            	//3.把socket对象交给一个线程池进行处理
                // 把socket封装成一个任务对象交给线程池处理
                Runnable target = new ServerRunnableTarget(socket);
                pool.execute(target);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

6.4、线程池处理类

public class HandlerSocketServerPool {
    //1. 创建一个线程池的成员变量用于存储一个线程池对象
    private ExecutorService executorService;
    
    /**
     * 2.创建这个类的的对象的时候就需要初始化线程池对象
     * public ThreadPoolExecutor(int corePoolSize,
     * int maximumPoolSize,
     * long keepAliveTime,
     * TimeUnit unit,
     * BlockingQueue<Runnable> workQueue)
     */
    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);
    }
}

6.5、Socket任务类

public class ServerRunnableTarget implements Runnable {
    private Socket socket;
    public ServerRunnableTarget(Socket socket){
    	this.socket = socket;
    }
    @Override
    public void run() {
        //处理接收到的客户端socket通信需求
        try {
            //1.从socket管道中得到一个字节输入流对象
            InputStream is = socket.getInputStream();
            //2.把字节输入流包装成一个缓存字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while((msg = br.readLine()) != null){
            	System.out.println("服务端收到：" + msg);
            }
        } catch (Exception e){
        	e.printStackTrace();
        }
    }
}

6.5、输出

服务端收到：client1
服务端收到：client2
服务端收到：client3
服务端收到：client4
java.net.SocketException: Connection reset
    at java.base/java.net.SocketInputStream.read(SocketInputStream.java:186)
    at java.base/java.net.SocketInputStream.read(SocketInputStream.java:140)
    at java.base/sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
    at java.base/sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
    at java.base/sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
    at java.base/java.io.InputStreamReader.read(InputStreamReader.java:185)
    at java.base/java.io.BufferedReader.fill(BufferedReader.java:161)
    at java.base/java.io.BufferedReader.readLine(BufferedReader.java:326)
    at java.base/java.io.BufferedReader.readLine(BufferedReader.java:392)
    at com.zhangxudong.ServerRunnableTarget.run(ServerRunnableTarget.java:23)
    at
    java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.j
    ava:1128)
    at
    java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.
    java:628)
    at java.base/java.lang.Thread.run(Thread.java:834)
服务端收到：client5

6.6、小结

  • 伪异步旧采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层 依然是采用的同步阻塞模型，因此无法从根采上解决问题。
  • 如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的I/O消息都将在队列 中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。
悬浮海
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java BIO NIO AIO
07-18
Java BIO NIO AIO Java BIO、NIO、AIO是 Java 中的三种 I/O 模式，每种模式都有其特点和应用场景。下面对每种模式进行详细解释。 Java BIO Java BIO（ Blocking I/O）是一种同步阻塞式的 I/O 模式，即服务器实现...
基于BIO的Java Socket通信详解
08-28
基于BIO的Java Socket通信详解 基于BIO的Java Socket通信是Java编程中的一种常见的网络通信方式。BIO指的是阻塞IO，在基于Socket的消息通信过程中，Socket服务端向外部提供服务，而Socket客户端可以建立到Socket...
Java I/O大揭秘：BIO、NIO、AIO到底有何区别？
孤芳不自赏
06-22 549
这篇文章你值得一阅！讲技术我觉得应该让外行也能看明白，而不是一堆专业术语堆砌，像在读天书一般，到最后感觉云里雾里。
深入探索Java BIO与NIO输入输出模型：基于文件复制和socket通信
码到三十五
02-02 1561
Java BIO和NIO是两种不同的I/O模型，它们在设计、工作原理和使用上有显著的区别。BIO是同步阻塞的I/O模型，它简单直接但性能有限；而NIO是同步非阻塞的I/O模型，它引入了多路复用器和缓冲区的概念，提高了系统的吞吐量和性能。在选择使用哪种模型时，需要根据具体的应用场景和需求进行权衡。如果并发连接数较少且对性能要求不高，可以选择使用BIO；如果并发连接数较多且对性能要求较高，可以选择使用NIO。
Java网络编程IO模型 --- BIO、NIO、AIO详解
最新发布
2301_82242988的博客
04-29 649
金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：大厂面试真题：金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：[外链图片转存中…(img-3ST7KdL7-1714389491204)]大厂面试真题：[外链图片转存中…(img-wIJZpwVt-1714389491205)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
Java基础BIO、NIO、AIO小结
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
10-25 853
BIO通信过程如下图所示，可以看到客户端成功与服务端建立连接后会因为等待服务端处理并响应结果而需要进行阻塞。而服务端在没有客户端发起请求时也会进入循环阻塞。并且服务端必须只有处理完这个请求后，才会去处理其他用户的请求。所以在高并发场景下，无论用户体验，还是服务器处理效率和压力都是灾难性的打击。
JAVA中BIO
爪哇人的博客
10-24 352
1 BIO基本介绍 BIO是就是传统的io编程，其相关的类和接口在Java.io BIO:同步阻塞，服务器实现模式为一个线程一个连接，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器) 2 BIO工作机制 3 同步阻塞案例 服务端代码： public class Server { /** * 客户端发送消息,服务端接收消息 *...
Java -- 什么是BIO
ZeroWdd的博客
05-04 2125
Java – 什么是BIO 1. Java BIO 基本介绍 Java BIO 就是传统的java io编程， 其相关的类和接口在java.io。 BIO：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)。 BIO 方式适用于连接数目比较小且固定的架...
Java BIO Socke示例
11-24
Java BIO (Blocking Input/Output) 是Java标准库中提供的一种基础网络编程模型，它主要用于创建基于TCP/IP的Socket通信服务。在这个"Java BIO Socke示例"中，我们将探讨如何使用Java BIO API来实现简单的Socket通信...
Java中BIO、NIO、AIO的理解
08-28
"Java中BIO、NIO、AIO的理解" Java中BIO、NIO、AIO的理解是Java高性能IO体系设计中三个重要的概念。它们都是Java中IO操作的实现方式，但它们之间有着很大的区别。 首先，我们需要了解什么是同步和异步，什么是阻塞...
biojava tutorial
03-10
biojava tutorial bioinformatics
JAVA BIO AIO NIO测试代码
09-01
对java io总结时编写的测试代码，包括BIO,NIO,AIO的实现，Java io操作是编程人员经常使用到的，以前只是使用没有对这三种IO做系统的了解，本文将对这三种IO作详细的介绍并附有测试完整代码
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
主要介绍了Java中网络IO的实现方式（BIO、NIO、AIO）介绍的相关资料,需要的朋友可以参考下
Java BIO
了凡
11-24 231
Java BIO Java BIO指的是blocking I/O，同步并阻塞式的IO 同步vs异步 同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication) 所谓同步，就是在发出一个调用时，在没有得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由调用者主动等待这个调用的结果。 而异步则是相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不
BIO_java代码_测试demo
fudaolai的博客
11-22 308
一,客户端 public class BioClient { public static void main(String[] args) throws IOException { //创建客户端socket Socket socket = new Socket("127.0.0.1",9001); OutputStream outputStream = socket.getOutputStream(); PrintStrea
【无标题】
flightfish的博客
07-04 266
I/O 模型简单理解为：就是使用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。Java 支持 3 种网络编程模型：BIO、NIO、AIO。Java BIO：（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不作任何事情会造成不必要的线程开销。Java NIO：，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求会被注册到多路复用器上，多路复用器轮询到有 I/O 请求就会进行处理。Java AIO：，AI
Java BIO编程
qq_45596525的博客
10-26 246
文章目录前言一、BIO、NIO、AIO基本概念二、BIO编程实例1. 简单流程2.编码3.如何使用CMD与服务器建立socket连接总结 前言 基于BIO的网络编程模型在大并发量下会浪费掉大量的I/O资源 , 基于Netty的网络编程方案则能较好的应对这一问题 提示：以下是本篇文章正文内容，下面案例可供参考 一、BIO、NIO、AIO基本概念 I/O模型就是使用什么样的通道进行数据的收发 Java支持三种网络编程的模型 : BIO,NIO,AIO BIO : 同步阻塞,传统的阻塞型 , 客户端发起连
【java】IO详解之BIO
热门推荐
峰峯的专栏
10-31 1万+
本文对java bio做了一个详细的总结，主要包括io的一些易混淆概念解释，使用易错点进行了示例，最后对java io的实际应用做了个尝试
java的BIO实现
张青山
06-25 1823
概述        该篇博客主要讲解BIO的使用，以及使用中存在一些问题。 单线程处理 package one; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; /** * BIO服务端 */ public
java bio 聊天室
10-14
关于 Java BIO 聊天室，我可以给你一些简单的介绍。 Java BIO（Blocking IO）是一种同步阻塞的 IO 模型，它的特点是在进行网络通信时，应用程序会一直等待数据的到来，直到数据到来才会进行处理。在 Java 中，我们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值