如何在run方法外发送对象？Java Socket双向通信流访问问题

咱们先拆解下你代码里的核心问题，然后一步步修正——你用每个客户端对应一个线程的思路是对的，但在Socket和流的管理上有几个关键错误，导致没法正常双向通信：

• 初始代码里每次循环都新建ObjectInputStream，还读完就关闭Socket，直接断开了连接，根本没法持续通信
• 补充后的ServerHandler重复创建了ServerSocket，完全没必要（Socket已经由主Server线程通过accept()获取并传入了），还会导致端口占用异常
• sendMessage调用时机可能早于流的初始化，会触发空指针异常
• 缺少客户端的双向通信实现，客户端也需要同时处理读写逻辑

修正后的完整实现 #

1. 服务器核心类 #

SuperServer.java（服务器入口）

import java.io.IOException;

public class SuperServer {
    private final Server server;

    public SuperServer() {
        this.server = new Server();
    }

    public void startServer() {
        server.setDaemon(true);
        server.start();
        System.out.println("Server started, waiting for clients...");
    }

    // 示例仅处理第一个连接的客户端，可扩展为集合管理多客户端
    public void sendMessage(String message) throws IOException {
        if (server.getActiveHandler() != null) {
            server.getActiveHandler().sendMessage(message);
        } else {
            throw new IOException("No connected client available");
        }
    }
}

Server.java（监听客户端连接）

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server extends Thread {
    private ServerSocket serverSocket;
    private ServerHandler activeHandler; // 记录当前活跃的客户端处理器

    @Override
    public void run() {
        try {
            serverSocket = new ServerSocket(4444);
            while (!isInterrupted()) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("New client connected: " + clientSocket.getInetAddress());
                // 为每个客户端创建独立的处理线程
                activeHandler = new ServerHandler(clientSocket);
                activeHandler.start();
            }
        } catch (IOException e) {
            System.err.println("Server error: " + e.getMessage());
        } finally {
            // 退出时关闭服务器Socket
            try {
                if (serverSocket != null && !serverSocket.isClosed()) {
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public ServerHandler getActiveHandler() {
        return activeHandler;
    }
}

ServerHandler.java（客户端通信处理器）

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

public class ServerHandler extends Thread {
    private final Socket clientSocket;
    private ObjectOutputStream oos;
    private ObjectInputStream ois;

    public ServerHandler(Socket socket) {
        this.clientSocket = socket;
        // 必须先初始化输出流（Java序列化流的特性，避免阻塞）
        try {
            this.oos = new ObjectOutputStream(clientSocket.getOutputStream());
            this.ois = new ObjectInputStream(clientSocket.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
            closeResources();
        }
    }

    public void sendMessage(String message) throws IOException {
        if (oos != null && !clientSocket.isClosed()) {
            oos.writeObject(message);
            oos.flush(); // 强制刷新缓冲区，确保消息即时发送
        }
    }

    @Override
    public void run() {
        try {
            String receivedMessage;
            // 持续读取客户端消息，直到连接断开
            while ((receivedMessage = (String) ois.readObject()) != null) {
                System.out.println("Server Received: " + receivedMessage);
                // 示例：收到消息后自动回复客户端
                sendMessage("Server echo: " + receivedMessage);
            }
        } catch (IOException e) {
            System.out.println("Client disconnected: " + clientSocket.getInetAddress());
        } catch (ClassNotFoundException e) {
            System.err.println("Received unknown object type: " + e.getMessage());
        } finally {
            closeResources();
        }
    }

    // 统一关闭资源，避免泄漏
    private void closeResources() {
        try {
            if (ois != null) ois.close();
            if (oos != null) oos.close();
            if (clientSocket != null && !clientSocket.isClosed()) clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 客户端实现（双向通信） #

SuperClient.java

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;

public class SuperClient extends Thread {
    private Socket serverSocket;
    private ObjectOutputStream oos;
    private ObjectInputStream ois;
    private final Scanner scanner;

    public SuperClient() {
        this.scanner = new Scanner(System.in);
    }

    public void clientStart() {
        try {
            serverSocket = new Socket("localhost", 4444);
            System.out.println("Connected to server");
            // 同样先初始化输出流
            oos = new ObjectOutputStream(serverSocket.getOutputStream());
            ois = new ObjectInputStream(serverSocket.getInputStream());
            // 启动独立线程读取服务器消息
            start();
            // 主线程负责用户输入并发送消息
            sendMessageLoop();
        } catch (IOException e) {
            e.printStackTrace();
            closeResources();
        }
    }

    private void sendMessageLoop() {
        try {
            String input;
            System.out.println("Enter messages to send to server (type 'exit' to quit):");
            while (!(input = scanner.nextLine()).equalsIgnoreCase("exit")) {
                sendMessage(input);
            }
        } finally {
            closeResources();
        }
    }

    public void sendMessage(String message) throws IOException {
        if (oos != null && !serverSocket.isClosed()) {
            oos.writeObject(message);
            oos.flush();
        }
    }

    @Override
    public void run() {
        try {
            String receivedMessage;
            while ((receivedMessage = (String) ois.readObject()) != null) {
                System.out.println("\nServer message: " + receivedMessage);
                System.out.print("Enter message: ");
            }
        } catch (IOException e) {
            System.out.println("Disconnected from server");
        } catch (ClassNotFoundException e) {
            System.err.println("Received unknown object type: " + e.getMessage());
        } finally {
            closeResources();
        }
    }

    private void closeResources() {
        scanner.close();
        try {
            if (ois != null) ois.close();
            if (oos != null) oos.close();
            if (serverSocket != null && !serverSocket.isClosed()) serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 主启动类 #

Main.java

import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 启动服务器
        SuperServer server = new SuperServer();
        server.startServer();
        // 给服务器一点启动时间
        Thread.sleep(1000);
        // 启动客户端
        SuperClient client = new SuperClient();
        client.clientStart();
    }
}

核心修正点说明 #

1. 流的生命周期管理：每个连接只创建一次ObjectOutputStream和ObjectInputStream，且必须先初始化输出流（Java序列化流的特性，否则会导致阻塞）
2. 资源安全关闭：用finally块统一关闭流和Socket，避免资源泄漏；不要在循环里关闭连接，否则会直接断开通信
3. 线程分工明确：主Server线程负责监听新连接，每个客户端由独立线程处理读写；客户端也用独立线程读取服务器消息，主线程处理用户输入
4. 避免空指针：发送消息前先检查流和Socket的状态，确保初始化完成后再操作
5. 即时发送消息：每次写对象后调用flush()，确保消息立即发送到网络缓冲区

内容的提问来源于stack exchange，提问作者nanobot