手把手实现Java BIO聊天室：从基础到优化，掌握高并发核心技巧！

最新推荐文章于 2025-08-31 13:15:44 发布
原创 最新推荐文章于 2025-08-31 13:15:44 发布 · 993 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #NIO

在这里插入图片描述

肖哥弹架构 跟大家“弹弹” BIO/NIO/AIO设计与实战应用，需要代码关注

欢迎 关注，点赞，留言。

关注公号Solomon肖哥弹架构获取更多精彩内容

历史热点文章

想彻底搞懂Java BIO模型？本文通过一个完整的多人在线聊天室项目，带你从零实现基于线程池优化的BIO服务端与客户端！包含：

  • ✅ 完整代码实现：服务端广播机制 + 客户端消息收发
  • ✅ 性能优化实战：线程池管理、ConcurrentHashMap应用、资源泄漏防护
  • ✅ 架构设计图：服务端/客户端交互流程
  • 🚀 扩展方向：对比NIO方案，揭示BIO的并发瓶颈与突破点

1. 项目概述

功能需求

  • 支持多个客户端通过 TCP 连接服务器。
  • 客户端发送的消息会被广播给所有其他客户端。
  • 服务端记录客户端连接和断开日志。

技术栈

  • BIO 模型：ServerSocket + Socket。
  • 线程池：ExecutorService 管理客户端连接线程。
  • 简单协议：消息以换行符 \n 分隔。

2. 系统架构图

2.1 服务端设计图

在这里插入图片描述

2.2 客户端设计图

在这里插入图片描述

2.3 交互时序图

在这里插入图片描述

3.普通版本

3.1 服务端完整代码

3.1.1 ChatServer.java
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;

/**
 * BIO 聊天服务端（线程池优化版）
 */
public class ChatServer {
    private static final int PORT = 8888;
    private static final Set<PrintWriter> clientWriters = new ConcurrentHashSet<>(); // 线程安全的客户端输出流集合
    /**
     *自动扩容**：根据需要创建新线程（无上限）
-    *自动回收**：60秒空闲线程会被回收
    **/
    private static ExecutorService threadPool = Executors.newCachedThreadPool();    // 动态大小的线程池

    public static void main(String[] args) {
        System.out.println("BIO 聊天服务器启动，监听端口: " + PORT);

        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            while (true) {
                // 1. 阻塞等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("客户端连接: " + clientSocket.getRemoteSocketAddress());

                // 2. 为每个客户端分配一个线程处理
                threadPool.execute(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 客户端处理线程
     */
    private static class ClientHandler implements Runnable {
        private Socket socket;
        private PrintWriter writer;

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

        @Override
        public void run() {
            try {
                // 1. 获取输入输出流
                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream())
                );
                writer = new PrintWriter(
                    new OutputStreamWriter(socket.getOutputStream()), true
                );

                // 2. 将当前客户端输出流加入集合
                clientWriters.add(writer);

                // 3. 循环读取客户端消息
                String message;
                while ((message = reader.readLine()) != null) { // 阻塞直到收到消息
                    System.out.println("收到消息: " + message);
                    broadcast(message); // 广播给所有客户端
                }
            } catch (IOException e) {
                System.out.println("客户端断开: " + socket.getRemoteSocketAddress());
            } finally {
                // 4. 清理资源
                if (writer != null) {
                    clientWriters.remove(writer);
                }
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        /**
         * 广播消息给所有客户端
         */
        private void broadcast(String message) {
            for (PrintWriter writer : clientWriters) {
                writer.println(message); // 自动刷新缓冲区
            }
        }
    }
}

3.2 客户端完整代码

3.2.1 ChatClient.java
import java.io.*;
import java.net.*;
import java.util.Scanner;

/**
 * BIO 聊天客户端
 */
public class ChatClient {
    private static final String HOST = "localhost";
    private static final int PORT = 8888;

    public static void main(String[] args) {
        try (
            Socket socket = new Socket(HOST, PORT);
            PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream())
            );
            Scanner scanner = new Scanner(System.in)
        ) {
            System.out.println("已连接到聊天服务器，输入消息开始聊天（输入 'exit' 退出）:");

            // 1. 启动子线程接收服务器消息
            new Thread(() -> {
                try {
                    String serverMessage;
                    while ((serverMessage = reader.readLine()) != null) {
                        System.out.println("收到广播: " + serverMessage);
                    }
                } catch (IOException e) {
                    System.out.println("与服务器断开连接");
                }
            }).start();

            // 2. 主线程发送用户输入
            while (true) {
                String userInput = scanner.nextLine();
                if ("exit".equalsIgnoreCase(userInput)) {
                    break;
                }
                writer.println(userInput); // 发送到服务器
            }
        } catch (IOException e) {
            System.err.println("连接服务器失败: " + e.getMessage());
        }
    }
}

4.线程池优化版

在这里插入图片描述

4.1. 优化点说明

  1. 线程池管理：使用 FixedThreadPool 控制最大线程数，防止线程爆炸
  2. 线程安全集合：改用 ConcurrentHashMap 替代 ConcurrentHashSet（Java 无原生 ConcurrentHashSet）
  3. 资源清理：添加更完善的连接断开处理逻辑
  4. 日志优化：添加更详细的连接状态日志

4.2. 服务端代码

import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;

/**
 * 优化后的BIO聊天服务器（线程池 + 线程安全集合）
 * 主要优化点：
 * 1. 使用固定大小线程池控制资源
 * 2. 使用ConcurrentHashMap管理客户端连接
 * 3. 增强异常处理和资源释放
 */
public class OptimizedChatServer {
    private static final int PORT = 8888;
    private static final int MAX_THREADS = 100; // 控制最大线程数
    
    // 使用ConcurrentHashMap管理客户端输出流（Key: 客户端ID，Value: PrintWriter）
    private static final Map<String, PrintWriter> clientWriters = new ConcurrentHashMap<>();
    
    // 使用固定大小的线程池（避免无限制创建线程）
    private static final ExecutorService threadPool = Executors.newFixedThreadPool(MAX_THREADS);

    public static void main(String[] args) {
        System.out.println("[服务器] BIO聊天服务器启动，监听端口: " + PORT);
        System.out.println("[服务器] 最大工作线程数: " + MAX_THREADS);

        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            while (true) {
                // 阻塞等待客户端连接
                Socket clientSocket = serverSocket.accept();
                
                // 为每个客户端生成唯一ID（IP+端口+时间戳）
                String clientId = clientSocket.getInetAddress() + ":" + 
                                clientSocket.getPort() + "-" + 
                                System.currentTimeMillis();
                
                System.out.printf("[服务器] 客户端连接: %s (ID: %s)\n", 
                                clientSocket.getRemoteSocketAddress(), 
                                clientId);

                // 将新连接交给线程池处理
                threadPool.execute(new ClientHandler(clientSocket, clientId));
            }
        } catch (IOException e) {
            System.err.println("[服务器] 启动失败: " + e.getMessage());
        } finally {
            threadPool.shutdown(); // 优雅关闭线程池
        }
    }

    /**
     * 客户端处理线程（内部类）
     */
    private static class ClientHandler implements Runnable {
        private final Socket socket;
        private final String clientId;
        private PrintWriter writer;

        public ClientHandler(Socket socket, String clientId) {
            this.socket = socket;
            this.clientId = clientId;
        }

        @Override
        public void run() {
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream()))) {
                
                // 初始化输出流（自动刷新缓冲区）
                writer = new PrintWriter(
                    new OutputStreamWriter(socket.getOutputStream()), true);
                
                // 将客户端添加到全局Map
                clientWriters.put(clientId, writer);
                
                // 通知所有客户端有新用户加入
                broadcast("[系统] 用户 " + clientId + " 加入聊天室");

                String message;
                // 循环读取客户端消息（阻塞点）
                while ((message = reader.readLine()) != null) {
                    System.out.printf("[消息] %s: %s\n", clientId, message);
                    
                    // 广播消息给所有客户端（排除自己）
                    broadcast(clientId + ": " + message);
                }
            } catch (IOException e) {
                System.out.printf("[服务器] 客户端 %s 异常断开: %s\n", 
                                 clientId, e.getMessage());
            } finally {
                // 清理资源
                if (writer != null) {
                    clientWriters.remove(clientId); // 从Map中移除
                }
                try {
                    socket.close();
                    broadcast("[系统] 用户 " + clientId + " 已退出");
                } catch (IOException e) {
                    System.err.println("[错误] 关闭socket失败: " + e.getMessage());
                }
            }
        }

        /**
         * 广播消息给所有客户端（线程安全）
         * @param message 要广播的消息
         */
        private void broadcast(String message) {
            // 遍历所有客户端输出流
            for (Map.Entry<String, PrintWriter> entry : clientWriters.entrySet()) {
                try {
                    PrintWriter writer = entry.getValue();
                    writer.println(message); // 自动刷新缓冲区
                } catch (Exception e) {
                    // 如果发送失败，移除失效的客户端
                    System.err.printf("[错误] 广播消息到 %s 失败: %s\n", 
                                    entry.getKey(), e.getMessage());
                    clientWriters.remove(entry.getKey());
                }
            }
        }
    }
}

4.3. 客户端代码

import java.io.*;
import java.net.*;
import java.util.Scanner;

/**
 * 优化后的BIO聊天客户端
 * 主要优化点：
 * 1. 使用try-with-resources自动关闭资源
 * 2. 更友好的用户提示
 * 3. 添加客户端昵称功能
 */
public class OptimizedChatClient {
    private static final String HOST = "localhost";
    private static final int PORT = 8888;
    private static String nickname; // 客户端昵称

    public static void main(String[] args) {
        System.out.println("=== BIO聊天客户端 ===");
        
        try (Scanner scanner = new Scanner(System.in)) {
            // 获取用户昵称
            System.out.print("请输入昵称: ");
            nickname = scanner.nextLine();
            
            // 建立连接
            try (Socket socket = new Socket(HOST, PORT);
                 PrintWriter writer = new PrintWriter(
                     new OutputStreamWriter(socket.getOutputStream()), true);
                 BufferedReader reader = new BufferedReader(
                     new InputStreamReader(socket.getInputStream()))) {
                
                System.out.println("已连接到服务器，开始聊天吧！(输入'exit'退出)");
                
                // 启动消息接收线程
                new Thread(() -> {
                    try {
                        String serverMessage;
                        while ((serverMessage = reader.readLine()) != null) {
                            System.out.println(serverMessage); // 显示服务器消息
                        }
                    } catch (IOException e) {
                        System.out.println("[错误] 与服务器断开连接");
                    }
                }).start();
                
                // 主线程处理用户输入
                while (true) {
                    String userInput = scanner.nextLine();
                    if ("exit".equalsIgnoreCase(userInput)) {
                        writer.println(nickname + " 离开了聊天室"); // 通知服务器
                        break;
                    }
                    writer.println(nickname + ": " + userInput); // 发送格式化的消息
                }
            } catch (ConnectException e) {
                System.err.println("连接服务器失败，请检查服务器是否运行");
            } catch (IOException e) {
                System.err.println("通信错误: " + e.getMessage());
            }
        }
        System.out.println("客户端已退出");
    }
}

4.4. 优化效果

指标原始版本优化版本
最大并发无限制（可能OOM）可控（MAX_THREADS）
线程安全使用非线程安全集合ConcurrentHashMap保证安全
资源泄漏风险高完善的finally块保证释放
功能扩展性差支持客户端唯一标识

5. 交互流程图

在这里插入图片描述

6. 关键设计说明

6.1 BIO 模型的核心问题

  • 阻塞点：
    • serverSocket.accept()：等待客户端连接。
    • reader.readLine()：等待客户端消息。
  • 优化方案：
    • 使用线程池避免为每个连接创建新线程（防止线程爆炸）。
    • ConcurrentHashSet 保证多线程安全。

6.2 性能瓶颈

  • 线程数限制：
    • 线程池大小需根据机器配置调整（用 CachedThreadPool 动态扩展）。
    • 高并发时（如 10k 连接），线程切换开销仍无法避免。

6.3 扩展性改进方向

  • NIO 重构：改用 Selector 实现单线程管理多连接（如 Netty）。
  • 协议优化：定义更复杂的消息格式（如 JSON 封装用户名）。

7. 运行方式

  1. 启动服务端：
    javac ChatServer.java
java ChatServer
  2. 启动多个客户端（新终端）：
    javac ChatClient.java
java ChatClient

8. 总结

  • BIO 的优势：代码简单直观，适合快速开发低并发应用。
  • BIO 的缺陷：线程资源消耗大，无法支撑高并发。
  • 生产建议：超过 1k 并发时，改用 NIO/Netty。

📌 思考题：如果客户端不发送 exit 直接关闭，服务端如何检测断开？
答案：捕获 IOException（如 readLine() 返回 null）。

Spring Boot进阶(20)：「打造高性能Web应用」——使用Jetty容器配置Spring Boot
**My Coding Family**
03-10 5996
SpringBoot如何配置Jetty容器，赶紧来学，手把手教你~~
Python从0到100（九十九）：基于空间注意力Spatial Attention Neural Network的网络设计与实现
热门推荐
全网粉丝10w+，CSDN、稀土掘金人工智能签约作者、专家博主，华为云十佳博主，985人工智能硕士。人工智能、大模型、计算机视觉、Python 爬虫— —商务合作：https://bbs.csdn.net/topics/614347534
06-11 5万+
Spatial Attention Neural Network（SANN） 是一种融合空间注意力机制的深度神经网络架构。它通过动态调整不同空间位置的注意力权重来突出重要的时序特征，在保持计算效率的同时显著提升了模型对时序数据的特征表达能力和分类性能。
2025年最新人类高质量 Java 学习路线，零基础到精通一条龙（万人收藏⭐️）
努力做最接地气的编程干货分享，感谢关注
08-20 2万+
Java 学习路线一条龙版 by 鱼皮。 原创不易，请勿抄袭，违者必究！ 大家好，我是鱼皮。现在网上的编程资料实在太多了，而且人人肯定都说自己的最好，那就导致大家又不知道怎么选了。大部分的博主推荐资源，也就是把播放量高的视频说一遍，水一期视频，没有一条很清晰的学习路线。 所以今天我的这个 Java 学习路线就做做减法，给大家来个一条龙服务，Java 要学的知识点、对应的最佳学习资源和预计要花费的时间，都安排的明明白白的，不用选了，有计划了，也别再迷茫和纠结了，就无脑跟着学就行了。 我还在文档中整理了链接.
怒肝 Java 学习路线一条龙！
F_xiao_chou的博客
08-26 1941
文章为转载 请关注鱼皮好友 持续获取 有效学习知识 现在网上的编程资料实在太多了，而且人人肯定都说自己的最好，那就导致大家又不知道怎么选了。大部分的博主推荐资源，也就是把播放量高的视频说一遍，水一期视频，没有一条很清晰的学习路线。 所以今天我的这个 Java 学习路线就做做减法，给大家来个一条龙服务，Java 要学的知识点、对应的最佳学习资源和预计要花费的时间，都安排的明明白白的，不用选了，有计划了，也别再迷茫和纠结了，就无脑跟着学就行了。 大纲 实在太长了，没办法全部展开，只能放个大纲了。。...
人类高质量 Java 学习路线【一条龙版】
Feng_clay的博客
12-04 2262
大家好，我是张讨嫌。现在网上的编程资料实在太多了，而且人人肯定都说自己的最好，那就导致大家又不知道怎么选了。大部分的博主推荐资源，也就是把播放量高的视频说一遍，水一期视频，没有一条很清晰的学习路线。 所以今天我的这个 Java 学习路线就做做减法，给大家来个一条龙服务，Java 要学的知识点、对应的最佳学习资源和预计要花费的时间，都安排的明明白白的，不用选了，有计划了，也别再迷茫和纠结了，就无脑跟着学就行了。 我还在文档中整理了链接，也不用自己搜了，还有思维导图。 大纲 实在太长了，没办法全部展开，
Java架构师，大数据架构师，高并发设计模式，机器学习知识点分享
u014033218的专栏
09-14 6969
第一章：java精品课程目录大全 1、亿级流量电商详情页系统的大型高并发与高可用缓存架构实战 1课程介绍以及高并发高可用复杂系统中的缓存架构有哪些东西？32分钟 2基于大型电商网站中的商品详情页系统贯穿的授课思路介绍7分钟 3小型电商网站的商品详情页的页面静态化架构以及其缺陷11分钟
java学习资料整理(开发必备)
m0_67537062的博客
03-30 1万+
收集的java学习资料整理了下，里面包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
java学习路线
w18377940962的博客
02-08 8985
Java 学习路线 Java 学习路线一条龙版 by 程序员鱼皮 ???? + ???? = ???????? 建议先观看视频导读：https://www.bilibili.com/video/BV1Qf4y1K7ff/ 大纲 路线特点 最新，完整一条龙的大厂 Java 学习路线，从入门到入土 同时适用于想全面学习 / 快速求职的同学，可以根据符号来定制自己的专属学习路线 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 鱼皮自己是 Java 开发者，融入个
java架构师进阶之路
henhenha的博客
03-30 5411
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
Java 学习路线一条龙版
程序员阿红的博客
12-02 1万+
Java 学习路线一条龙版 Java 学习路线一条龙版 by 程序员鱼皮 ???? + ???? = ???????? 学习路线来源于：程序员鱼皮，大家可以去b站看看他的视频。 视频导读：https://www.bilibili.com/video/BV1Qf4y1K7ff/ 大纲 路线特点 最新，完整一条龙的大厂 Java 学习路线，从入门到入土 同时适用于想全面学习 / 快速求职的同学，可以根据符号来定制自己的专属学习路线 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文
【JAVA】采购ERP系统核心模块技术解密：寻源与合同管理的高并发架构实践
王大师企业官方博客
04-01 1764
本文所述方案已在某世界500强企业的采购系统中落地验证，支撑日均10万+询价单处理能力。询价单创建平均RT：127ms学习教程（传送门）1、掌握JAVA入门到进阶知识(持续写作中……2、学会Oracle数据库用法(创作中……3、手把手教你vbs脚本制作(完善中……4、牛逼哄哄的IDEA编程利器(编写中……5、吐血整理的面试技巧(更新中……往期文章第一章：日常_JAVA_面试题集15（含答案）第二章：日常_JAVA_面试题集14（含答案）
手把手教你在Java后端使用bsdiff实现增量更新
喻志强的博客
12-18 4732
之前写过一篇博客是在Android上使用bsdiff实现增量更新的功能. 本篇博客来看一看Java 后端的bsdiff增量更新是如何实现的。顺便看一下后端JNI的实现过程，怎么把C 代码编译成linux上需要的so文件等
【实战篇】手把手教你本地私有化部署DeepSeek全攻略：从硬件选型到避坑指南（超详细万字长文）
商务合作|问题讨论|交流学习 请联系作者微信，加微信请务必注明来意，博客主页有联系方式
02-19 3892
最近AI圈最火的大模型非DeepSeek莫属！这个号称"推理能力堪比GPT-4o"的国产大模型，不仅开源免费，还能在普通电脑上运行。今天我就用最接地气的语言，给你掰开了揉碎了讲清楚。
【YOLOv8十万长文优化】独家魔改优化技巧+附20余个源码手把手教程
cv君的博客
08-01 2万+
【YOLOv8十万长文全解】v8 v9通用。独家魔改优化技巧+附20余个源码手把手教程; Hello，大家好，我是cv君，最近开始在空闲之余，经常更新文章啦！除目标检测、分类、分隔、姿态估计等任务外，还会涵盖图像增强领域，如超分辨率、画质增强、降噪、夜视增强、去雾去雨、ISP、海思高通成像ISP等、AI-ISP、还会有多模态、文本nlp领域、视觉语言大模型、lora、chatgpt等理论与实践文章更新，更新将变成一周2-3更，一个月争取10篇，重回创作巅峰
常见排序算法及Java实现
xike1024的博客
08-27 1448
常见排序算法及Java代码实现
GDPU操作系统实验：生产者消费者问题
最新发布
平平无奇的小甜菜
08-31 804
本文摘要：实验通过信号量机制实现生产者-消费者模型，建立大小为10的缓冲区，使用3个生产者线程随机生成大小写字母，2个消费者线程取出字符。通过empty、full和mutex信号量实现同步与互斥，确保缓冲区访问安全。进阶实验扩展为选择性消费，增加3类消费者（仅小写/仅大写/任意字符），通过额外信号量管理不同类型产品。实验验证了进程同步中共享资源管理的有效性，演示了环形缓冲区和多线程协调的实现方法，为操作系统并发控制提供了实践案例。（149字）
软件开发整体介绍和Swagger介绍和使用步骤
qq_66753768的博客
08-27 2012
介绍之前我们先了解一下软件开发流程1.需求分析2.设计3.编码4.测试5.上线运维（1）第一阶段：需求分析完成需求规格说明书、产品原型编写。需求规格说明书， 一般来说就是使用 Word 文档来描述当前项目的各个组成部分，如：系统定义、应用环境、功能规格、性能需求等，都会在文档中描述（2）第2阶段：设计设计的内容包含 UI设计、数据库设计、接口设计。UI设计：用户界面的设计，主要设计项目的页面效果，小到一个按钮，大到一个页面布局，还有人机交互逻辑的体现。
145. 二叉树的后序遍历【简单】
伍六琪的博客
08-29 274
给你一棵二叉树的根节点 root ，返回其节点值的后序遍历 。【分别使用递归遍历和迭代遍历两种方式解决二叉树的后序遍历问题。】
基于SpringBoot的私人健身与教练预约管理系统
weixin_43405647的博客
08-28 1047
本文介绍了一个基于SpringBoot的私人健身与教练预约管理系统。该系统旨在解决传统健身房管理模式的痛点，采用双端分离架构，包含管理端和用户端。管理端提供用户管理、教练管理、预约管理等核心功能；用户端则实现项目查询、教练预约等服务。系统运用SpringBoot、MySQL、Vue.js等技术栈，具有模块化设计、扩展性强等特点，为健身行业数字化转型提供智能化解决方案。文中还展示了系统架构图和各功能模块界面，完整呈现了这一健身管理平台的技术实现方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Solomon_肖哥弹架构

你的欣赏就是我最大的动力

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

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

打赏作者

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

抵扣说明：

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

余额充值