多主机 TCP 通信

下面我会以最常见的 多主机 TCP 通信 为例，提供一个可直接运行的完整示例，帮你理解 Java 如何处理多主机交互的核心逻辑。

核心实现思路

设计一个通用的 HostClient 类，封装与单个主机的连接、数据发送 / 接收逻辑
使用线程池管理多个主机的连接（避免单线程阻塞，提高并发效率）
主线程统一调度，向多个不同主机发送请求并处理响应

完整代码示例

java

运行

复制代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 多主机交互的核心示例
 * 功能：同时连接多个远程主机，发送消息并接收响应
 */
public class MultiHostCommunication {

    // 线程池（核心数根据CPU核心数调整，适合处理多主机并发）
    private static final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);

    public static void main(String[] args) {
        // 定义需要交互的多主机列表（IP+端口）
        List<HostInfo> hostList = new ArrayList<>();
        hostList.add(new HostInfo("192.168.1.100", 8080, "Hello Host 1!"));
        hostList.add(new HostInfo("192.168.1.101", 8080, "Hello Host 2!"));
        hostList.add(new HostInfo("192.168.1.102", 8080, "Hello Host 3!"));

        // 并发处理多主机请求
        for (HostInfo host : hostList) {
            executor.submit(() -> {
                try (HostClient client = new HostClient(host.getIp(), host.getPort())) {
                    // 发送消息
                    client.sendMsg(host.getMsg());
                    // 接收响应
                    String response = client.receiveMsg();
                    System.out.printf("主机 %s:%d 响应：%s%n", host.getIp(), host.getPort(), response);
                } catch (IOException e) {
                    System.err.printf("连接主机 %s:%d 失败：%s%n", host.getIp(), host.getPort(), e.getMessage());
                }
            });
        }

        // 关闭线程池（等待所有任务完成）
        executor.shutdown();
        try {
            if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }

    /**
     * 主机信息封装类
     */
    static class HostInfo {
        private final String ip;
        private final int port;
        private final String msg;

        public HostInfo(String ip, int port, String msg) {
            this.ip = ip;
            this.port = port;
            this.msg = msg;
        }

        // getter方法
        public String getIp() { return ip; }
        public int getPort() { return port; }
        public String getMsg() { return msg; }
    }

    /**
     * 单个主机的通信客户端
     */
    static class HostClient implements AutoCloseable {
        private final Socket socket;
        private final OutputStreamWriter writer;
        private final BufferedReader reader;

        // 构造方法：建立与单个主机的连接
        public HostClient(String ip, int port) throws IOException {
            this.socket = new Socket(ip, port);
            this.writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
            this.reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
        }

        // 发送消息到主机
        public void sendMsg(String msg) throws IOException {
            writer.write(msg + "\n"); // 换行作为消息结束标识
            writer.flush();
        }

        // 接收主机的响应
        public String receiveMsg() throws IOException {
            return reader.readLine(); // 读取一行响应
        }

        // 关闭连接（实现AutoCloseable，支持try-with-resources）
        @Override
        public void close() throws IOException {
            if (reader != null) reader.close();
            if (writer != null) writer.close();
            if (socket != null) socket.close();
        }
    }
}

代码关键说明

线程池（ExecutorService）：
- 核心作用是并发处理多主机连接，避免为每个主机创建独立线程导致资源耗尽
- newFixedThreadPool 固定线程数，适合处理数量可控的多主机场景
HostClient 类：
- 封装了单个主机的 TCP 连接、发送、接收逻辑
- 实现 AutoCloseable 接口，配合 try-with-resources 语法自动关闭连接，避免资源泄漏
异常处理：
- 针对每个主机的连接 / 通信异常单独捕获，不会因为一个主机失败导致整个程序终止
- 线程池的优雅关闭（shutdown() + awaitTermination()），确保所有任务有足够时间执行

扩展场景适配

如果你的 "多主机" 需求不是 TCP 通信，可基于此框架调整核心逻辑：

多主机 HTTP 请求 ：替换 HostClient 为 HttpClient（Java 11+ 内置），并发调用多个主机的 HTTP 接口
多主机文件传输 ：基于 FTP/SFTP 协议（可使用 JSch 库），批量向多主机上传 / 下载文件
多主机状态监控：定时向多主机发送心跳包，检测主机是否在线

总结

Java 处理多主机交互的核心是并发编程 （线程池）+ 资源封装（单个主机的交互逻辑）
必须为每个主机的交互单独处理异常，避免 "一个主机失败影响全部"
优先使用 try-with-resources 管理网络连接、流等资源，防止资源泄漏