Java 网络编程(BIO)

起个铭子2023-08-31 13:51

前提

  • 熟悉Java IO
  • 了解socket

了解基础BIO

BIO（Block IO）也就是阻塞IO

白话：当一个客户端连接到服务端时，如果服务端仅仅是单线程处理该客户端的连接时，当服务端未处理完当前客户端的连接，另外一个新的客户端连接到当前服务端，该连接就会被阻塞（无法连接），仅仅当服务端处理完上一个客户端的连接后新的客户端才能连接成功。

BIO代码示例
arduino 复制代码 
/**
 * BIO 示例
 */
public class BIOSocketServer {
    public static void main(String[] args) {
        //while---true 非处理单连接后结束线程
        //创建一个服务端socket，监听系统9090端口
        try {
            ServerSocket serverSocket = new ServerSocket(9090);
            while (true) {
                //等待客户端连接
                Socket socketServer = serverSocket.accept();  //阻塞
                System.out.println("客户端:" + socketServer.getInetAddress().getHostName() + "连接成功");
                //读取客户端发送的数据
                InputStream inputStream = socketServer.getInputStream();
                OutputStream outputStream = socketServer.getOutputStream();
                while (true) {

                    //限定接收1024个字节
                    byte[] buffer = new byte[1024];
                    int read = inputStream.read(buffer);  //等待阻塞
                    String s = "";
                    if (read != -1) {
                        s = new String(buffer, 0, read);
                        System.out.println("客户端：" + s);
                    }

                    //响应客户端，接收成功
                    outputStream.write("服务端：我已经收到你的数据----->".concat(s).getBytes(StandardCharsets.UTF_8));

                    //结束继续接收当前客户端数据
                    if (s.equals("exit")) break;
                }
                //释放资源
                outputStream.close();
                inputStream.close();
                socketServer.close();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);

        }

    }
}

这是每个客户端用来接收读取服务端发送数据线程

csharp 复制代码 
/**
 *  读取客户端发送过来的数据
 */
public class ReadThread extends Thread{
   private Socket client;
   public ReadThread(Socket client){
      this.client = client;
   }

    public void run() {
        try {
                while (true) {
                    //读取客户端发送过来的数据
                    byte[] buf = new byte[1024];
                    int len = client.getInputStream().read(buf);
                    if (len == -1) {
                        break;
                    }
                    System.out.println(new String(buf, 0, len, "utf-8"));
                }
        }catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

测试

  • 启动服务端程序，debug可以发现代码在这里阻塞了，一直等待有客户端连接进来
ini 复制代码 
Socket socketServer = serverSocket.accept();  //阻塞
  • 模拟启动第一个客户端连接服务端
java 复制代码 
/**
 * 客户端1
 */
public class ClientSocket1 {
    public static void main(String[] args) {

        try {
            //本地主机+端口号
            String host = "127.0.0.1";
            int port = 9090;

            //连接服务端
            Socket socket = new Socket(host, port);

            //开启一个线程，读取服务端返回的数据
            new ReadThread(socket).start();

            //发送数据
            OutputStream outputStream = socket.getOutputStream();
            //读取控制台数据,发送给服务端
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                outputStream.write(scanner.nextLine().getBytes(StandardCharsets.UTF_8));
                //刷新缓冲区
                outputStream.flush();
            }

            socket.close();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

debug发现上面执行到Socket socket = new Socket(host, port);时，服务端的Socket socketServer = serverSocket.accept(); //阻塞跑通了

  • 当客户端不发送数据给服务端端时

debug时候可以发现服务端代码一直阻塞在int read = inputStream.read(buffer); //等待阻塞 中，服务端一直等待读取客户都发送数据

  • 模拟启动第二个客户端程序，（这时服务端还在处理客户端1）
java 复制代码 
/**
 * 客户端2
 */
public class ClientSocket2 {
    public static void main(String[] args) {

        try {
            //本地主机+端口号
            String host = "127.0.0.1";
            int port = 9090;

            //连接服务端
            Socket socket = new Socket(host, port);

            //开启一个线程，读取服务端返回的数据
            new ReadThread(socket).start();

            //发送数据
            OutputStream outputStream = socket.getOutputStream();
            //读取控制台数据,发送给服务端
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                outputStream.write(scanner.nextLine().getBytes(StandardCharsets.UTF_8));
                //刷新缓冲区
                outputStream.flush();
            }

            socket.close();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

启动这第二个客户端程序连接9090端口服务端，debug发现客户端2没有在Socket socket = new Socket(host, port);这个位置阻塞，可是这个时候服务端处理的连接是客户端1

  • 模拟两个客户端都发送数据给服务端

可以发现客户端2，发送数据给服务端，服务端根本没有收到，说明客户端2没有连接服务端成功，因为服务端正在处理客户端1的连接。

  • 客户端1断开服务端连接

可以发现，当客户端1断开与服务端连接时，客户端2之前连接服务端阻塞被放开了，服务端就处理客户端2的连接,并且能接收到客户端2之前阻塞时发送给服务端的数据。

基础BIO存在问题

服务器在单线程的情况下，只能处理单个客户端器的连接，当新的客户端与服务端连接时就会被阻塞。

解决基础BIO存在的问题

上面服务端处理客户端连接都是单线程的，所以一次只能处理一个客户端连接，那每次连接过来一个客户端，服务端就开一个线程来处理与客户端的连接（或者使用线程池）。

java 复制代码 
public class ThreadPoolManager
{
    private static ThreadPoolManager sThreadPoolManager = new ThreadPoolManager();
    private static final int SIZE_CORE_POOL = 50;
    private static final int SIZE_MAX_POOL = 50;
    private static final int TIME_KEEP_ALIVE = 30;

    public static ThreadPoolManager singleInstance() {
        return sThreadPoolManager;
    }

    private final ThreadPoolExecutor mThreadPool = new ThreadPoolExecutor(50, 50, 30L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

    public void perpare() {
        if (this.mThreadPool.isShutdown() && !this.mThreadPool.prestartCoreThread())
        {
            int i = this.mThreadPool.prestartAllCoreThreads();
        }
    }

    //添加任务
    public void addExecuteTask(Runnable task) {
        if (task != null) {
            this.mThreadPool.execute(task);
        }
    }


    protected boolean isTaskEnd() {
        if (this.mThreadPool.getActiveCount() == 0) {
            return true;
        }
        return false;
    }


    public void shutdown() {
        this.mThreadPool.shutdown();
    }
}

对应Runnable

arduino 复制代码 
/**
 *  处理客户端连接的任务
 */
public class HandleClientRunnable  implements Runnable{
    private Socket socketServer;
    public HandleClientRunnable(Socket socketServer){
        this.socketServer = socketServer;
    }

    @Override
    public void run() {
        try {
            System.out.println("客户端:" + socketServer.getInetAddress().getHostName() + "连接成功");
            //读取客户端发送的数据
            InputStream inputStream = socketServer.getInputStream();
            OutputStream outputStream = socketServer.getOutputStream();
            while (true) {
    
                //限定接收1024个字节
                byte[] buffer = new byte[1024];
                int read = inputStream.read(buffer);  //等待阻塞
                String s = "";
                if (read != -1) {
                    s = new String(buffer, 0, read);
                    System.out.println("客户端：" + s);
                }
    
                //响应客户端，接收成功
                outputStream.write("服务端：我已经收到你的数据----->".concat(s).getBytes(StandardCharsets.UTF_8));
    
                //结束继续接收当前客户端数据
                if (s.equals("exit")) break;
            }
            //释放资源
            outputStream.close();
            inputStream.close();
            socketServer.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

加入线程池后的BIO服务端程序

java 复制代码 
/**
 * BIO 开线程处理
 */
public class BIOSocketServer {
    public static void main(String[] args) {
        //while---true 非处理单连接后结束线程
        //创建一个服务端socket，监听系统9090端口
        try {
            ServerSocket serverSocket = new ServerSocket(9090);
            ThreadPoolManager threadPoolManager = ThreadPoolManager.singleInstance();
            while (true) {
                //等待客户端连接,一个客户端连接过来后直接放开，第二个循环阻塞等待第二个连接过来，依次类推
                Socket socketServer = serverSocket.accept();  //阻塞,
                //使用线程池处理客户端连接
                threadPoolManager.addExecuteTask(new HandleClientRunnable(socketServer));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);

        }

    }
}

两个客户端程序不变，同时开启，并且两个都发送数据给服务端

可以发现，服务端可以同时处理多个客户端的连接，解决了基础BIO问题

引发新的问题

- C10K \ C10M问题

当开线程去处理新的连接，这个做法只能用在客户端极少的情况，因为开线程是极其消耗系统资源的，当客户端并发存在上万千万的时候，那么系统内存资源全部用来开线程了，还没等全部处理完，就玩球球了，开线程池处理虽然可以防止系统资源开销过大，但是处理并发量是很有限的。这就是BIO的弊端，解决这个弊端------>NIO(非阻塞IO)

相关推荐
魔道不误砍柴功1 小时前
Java 中如何巧妙应用 Function 让方法复用性更强
java·开发语言·python
NiNg_1_2341 小时前
SpringBoot整合SpringSecurity实现密码加密解密、登录认证退出功能
java·spring boot·后端
闲晨1 小时前
C++ 继承：代码传承的魔法棒，开启奇幻编程之旅
java·c语言·开发语言·c++·经验分享
测开小菜鸟3 小时前
使用python向钉钉群聊发送消息
java·python·钉钉
P.H. Infinity4 小时前
【RabbitMQ】04-发送者可靠性
java·rabbitmq·java-rabbitmq
生命几十年3万天4 小时前
java的threadlocal为何内存泄漏
java
caridle4 小时前
教程：使用 InterBase Express 访问数据库（五）：TIBTransaction
java·数据库·express
^velpro^4 小时前
数据库连接池的创建
java·开发语言·数据库
苹果醋34 小时前
Java8-＞Java19的初步探索
java·运维·spring boot·mysql·nginx
秋の花4 小时前
【JAVA基础】Java集合基础
java·开发语言·windows
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除