Java IO - BIO 基于网络编程案例分析

最新推荐文章于 2024-03-22 15:37:02 发布
最新推荐文章于 2024-03-22 15:37:02 发布
阅读量403 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ladymarry/article/details/129218348
版权

👑 博主简介：知名开发工程师
👣 出没地点：北京
💊 2023年目标：成为一个大佬
———————————————————————————————————————————
版权声明：本文为原创文章，如需转载须注明出处，喜欢可收藏！

一. Java BIO 基本介绍

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

二. Java BIO 常见案例

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

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

1. 基本案例

一个简单客户端，服务端通信案例，学过 java 网络编程基础，应该看得懂

//客户端
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);
        // （4）开始发送消息
        ps.println("我是客户端，我想约你吃小龙虾！！！");
        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);
        }
    }
}

小结

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

2. 模式下多发和多收消息

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

// 客户端
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);
        // （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 {
        String s = "886";
        System.out.println("886".equals(s));
        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. BIO模式下接收多个客户端

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

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

4. 伪异步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 请求将被拒绝，客户端会发生大量连接超时。

6. 基于BIO形式下的文件传输

支持任意类型文件形式的上传
客户端：

public static void main(String[] args) {
    try {
        InputStream is = new FileInputStream("C:\\Users\\java.png");
        //  1、请求与服务端的Socket链接
        Socket socket = new Socket("127.0.0.1", 8888);
        //  2、把字节输出流包装成一个数据输出流
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        //  3、先发送上传文件的后缀给服务端
        dos.writeUTF(".png");
        //  4、把文件数据发送给服务端进行接收
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) > 0) {
            dos.write(buffer, 0, len);
        }
        dos.flush();
        Thread.sleep(10000);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

服务端

public static void main(String[] args) {
    try{
        ServerSocket ss = new ServerSocket(8888);
        while (true){
            Socket socket = ss.accept();
            // 交给一个独立的线程来处理与这个客户端的文件通信需求。
            new ServerReaderThread(socket).start();
        }
    }catch (Exception e){
        e.printStackTrace();
    }
}

//线程类
public class ServerReaderThread extends Thread {
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try{
            // 1、得到一个数据输入流读取客户端发送过来的数据
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            // 2、读取客户端发送过来的文件类型
            String suffix = dis.readUTF();
            System.out.println("服务端已经成功接收到了文件类型：" + suffix);
            // 3、定义一个字节输出管道负责把客户端发来的文件数据写出去
            OutputStream os = new FileOutputStream("C:\\Users\\"+
                    UUID.randomUUID().toString()+suffix);
            // 4、从数据输入流中读取文件数据，写出到字节输出流中去
            byte[] buffer = new byte[1024];
            int len;
            while((len = dis.read(buffer)) > 0){
                os.write(buffer,0, len);
            }
            os.close();
            System.out.println("服务端接收文件保存成功！");

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

三. 即时通信综合案例

基于BIO模式下的即时通信，我们需要解决客户端到客户端的通信，也就是需要实现客户端与客户端的端口消息转发逻辑。

1. 项目案例说明

功能清单简单说明：

  1. 客户端登陆功能：需要输入用户名和服务端ip地址
  2. 在线人数实时更新：客户端用户户登陆以后，需要同步更新所有客户端的联系人列表
  3. 离线人数更新：检测到有客户端下线后，需要同步更新所有客户端的联系人列表
  4. 群聊：任意一个客户端的消息，可以推送给当前所有客户端接收
  5. 私聊：可以选择某个员工，点击私聊按钮，然后发出的消息可以被该客户端单独接收
  6. @消息：可以选择某个员工，然后发出的消息可以@该用户
  7. 记录消息时间点：服务端可以实时记录该用户的消息时间点，然后进行消息的多路转发或者选择。

2. 项目代码结构演示

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

在这里插入图片描述

3. 项目启动步骤

  1. 首先需要启动服务端，点击ServerChat类直接右键启动，显示服务端启动成功
  2. 其次，点击客户端类ClientChat类，在弹出的方框中输入服务端的ip和当前客户端的昵称
  3. 私聊：需要点击选中某人，然后勾选私聊即可发送私聊消息
    在这里插入图片描述

如需完整代码可自行下载：java socket 多人聊天室源码

北京李嘉城
关注
专栏目录
Java IO模型：BIO、NIO、AIO讲解
流楚丶格念的博客
10-17 2037
IO，Input/Output 简写，是指内存和外设之间的数据复制的过程。输入是指数据从外设复制到内存中， 输出则是指数据从内存复制到外设。目前，IO 可以通过数据流、序列化和文件系统为系统提供输入和输出而Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。Java IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。
Java编程性能优化技巧有哪些共7页.pdf.zip
10-29
在Java编程领域，性能优化是...以上只是一部分常见的Java性能优化技巧，实际文档可能包含更多具体实践和案例分析。在进行性能优化时，应遵循"先测量再优化"的原则，通过性能测试工具找出真正的问题所在，避免盲目优化。
【java】IO详解之BIO
热门推荐
峰峯的专栏
10-31 1万+
本文对java bio做了一个详细的总结，主要包括io的一些易混淆概念解释，使用易错点进行了示例，最后对java io的实际应用做了个尝试
Java的IO之BIO
好看的皮囊千篇一律，有趣的灵魂万里挑一。
03-22 609
Java IO流是用于处理输入和输出的机制，用于读取和写入数据。Java提供了丰富的IO类和接口，用于处理不同类型的数据和操作。Java中的IO模型主要分为BIO和NIO两种，他们可以分别被视为IO编程的不同风格或模式，并非IO流具体的类型，主要为BIO,NIO和AIO（NIO的升级版）。这篇我们主要围绕BIO进行，介绍BIO的相关使用和案例。
JAVA IO模式 —— BIO、NIO、AIO
Fearless____的博客
03-10 705
在java的软件设计开发中，通信架构是不可避免的，我们在进行不同系统或者不同进程之间的数据交互，或者在高并发下的通信场景下都需要用到网络通信相关的技术，Java共支持3种网络编程的I/O模型：BlO、NIO、AlO 这三种模式的演变是 BIO -> NIO -> AIO，各自具有不同的优缺点，实际通信需求下，要根据不同的业务场景和性能需求决定选择不同的I/O模型
JavaIO流：BIO梳理
栗筝i的博客
11-24 3391
BIO（blocking I/O） ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）。 本篇内容包括：Java BIO 介绍、Java BIO 工作机制、BIO 案例。
netty网络编程.pdf
11-26
它是Java平台上进行网络编程的强大工具，尤其在处理高并发、长连接的场景下表现出色。 1. IO概念 - BIO（Blocking I/O）：同步阻塞I/O，是最传统的I/O模型，当进行读写操作时，调用方法会一直阻塞，直到数据读取或...
阿里Java面试-69个必会问题.rar
06-06
这些只是部分可能出现在面试中的Java知识点，实际的压缩文件可能还会包含更多关于网络编程、数据库操作、算法与数据结构等方面的问题。为了在面试中脱颖而出，应聘者需要对这些知识点有深入的理解，并能够结合实际...
NIO学习-Java源代码分享(含netty)
10-22
Java NIO（New IO）是Java 1.4版本引入的一个新模块，它提供了一种新的I/O方式，与传统的BIO（Blocking I/O）相比，NIO具有更好的性能和可伸缩性，尤其在处理大量并发连接时。NIO的核心组件包括Channel、Buffer和...
netty视频详解（90节大长篇）
10-25
- **NIO介绍**：Java NIO (New IO) 是Java 1.4版本后引入的新API，用于替代传统的BIO (Blocking IO)，旨在提高文件读写的性能。 - **NIO关键组件**： - **Buffer**：缓冲区，用于数据的存储与处理。 - **Channel**...
互联网大厂Java面试题合集
03-22
- **改进案例**：例如对某个工具的性能瓶颈进行分析，通过重构或引入更高效的技术来提升其运行效率。 ##### 8.1.3 提升Python扫描速度与GIL锁的理解 - **提升Python扫描速度**：可以通过并行处理、异步编程、使用C...
java20210325
03-25
学习Java涵盖了语法基础、类与对象、异常处理、集合框架、多线程、IO流、网络编程、数据库连接、JDBC、设计模式等多个方面。 【压缩包子文件的文件名称列表】"java20210325-master"通常在开源项目中，"master"分支...
Java高级开发工程师面试笔记.zip
07-19
- **IO/NIO/BIO**：理解I/O操作的基本概念，对比分析阻塞与非阻塞IO，了解NIO的Channel、Buffer和Selector等核心组件。 2. **设计模式**： - **常用设计模式**：熟悉单例、工厂、代理、装饰器、观察者、适配器、...
字节等大厂面试大全JAVA.zip
最新发布
05-01
4. **IO/NIO/BIO**：了解I/O流的不同分类，理解非阻塞I/O（NIO）的优势及其使用场景。 接着，深入学习JVM相关知识： 1. **JVM内存模型**：理解堆、栈、方法区、本地方法栈等区域的划分和作用。 2. **类加载机制**：...
httpcore-nio-4.3.jar包
07-01
Java NIO（New IO）是Java 1.4引入的一套新的I/O API，替代了传统的BIO（Blocking IO）。NIO的核心概念包括通道（Channel）、缓冲区（Buffer）和选择器（Selector）。通道可以读写数据，缓冲区用于临时存储数据，...
Java IO与NIO的区别、BIO、NIO、AIO
try to do
03-31 4093
https://www.cnblogs.com/aspirant/p/8630283.html 一、概念 NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。 在Java API中提供了两套NIO， 一套是针对标准输入输出NIO 另一套就是网络编程NIO 二、NIO和IO的主要区别 下表总...
Java中IO流的分类和BIO,NIO,AIO的区别
QLH的博客
06-25 2696
.到底什么是IO，我们常说的IO，指的是文件的输入和输出，但是在操作系统层面是如何定义IO的呢？到底什么样的过程可以叫做是一次IO呢？ 拿一次磁盘文件读取为例，我们要读取的文件是存储在磁盘上的，我们的目的是把它读取到内存中。可以把这个步骤简化成把数据从硬件（硬盘）中读取到用户空间中。
java IO模型之BIO
wdquan19851029的专栏
10-24 130
java BIO模型是同步阻塞的，每当客户端发起一个请求，服务器端都要开启一个线程进行处理。 问题如下： 高并发场景下，会建立大量TCP链接，并且服务端需要创建大量线程进行处理，系统资源占用较大，造成服务器资源耗尽，从而崩溃。 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在read()操作上，造成线程资源浪费 BIO适用于并发量小，并且连接时间段的场景下。 下面给出一个BIO的例子 服务器端代码： 服务器端监听6666端口。 import java.io.IOException;.
java中的三种IO（BIO、NIO、AIO）
未来可期的博客
05-16 5513
IO 阻塞和非阻塞主要指的是访问 IO 的线程是否会阻塞（或者说是等待） 线程访问资源，该资源是否准备就绪的一种处理方式 BIO(传统的IO) BIO是同步阻塞式的IO，以流的方式处理数据（效率低） Socket编程就是BIO，一个socket连接处理一个线程。当多个socket请求与服务端建立连接时，服务端不能提供相应数量的处理线程，没有分配到处理线程的连接自然就会阻塞或者是被拒绝了。 ...
Java网络编程：IO模型深度解析-BIO、NIO、AIO
Java IO相关基础知识主要涵盖网络通信协议、套接字（Socket）以及Java提供的不同IO模型。在Java编程中，理解和掌握这些知识对于构建高效、可扩展的网络应用至关重要。 首先，我们要了解网络通信的基础，即IP协议。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

北京李嘉城

我的好兄弟啊，感谢大佬的火箭！

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

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

打赏作者

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

抵扣说明：

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

余额充值