Java StreamCorruptedException:无效类型代码：00

服务器代码：

while (true) {                                  
    Socket sock = serv.accept(); 
    try {
        new ClientSession(sock, outQueue, activeSessions);
        System.out.println("CS");
    } catch (IOException e) {
        System.out.println("Sock error");
        sock.close();
    }
}

客户会议：

class ClientSession extends Thread {
private Socket socket;
private OutboundMessages outQueue;
private ActiveSessions activeSessions;
private ObjectInputStream netIn;
private ObjectOutputStream netOut;
int n = 0;
boolean inGame = false;
boolean ready = false;
Player p;

public ClientSession(Socket s, OutboundMessages out, ActiveSessions as)
        throws IOException {
    socket = s;
    outQueue = out;
    activeSessions = as;
    netOut = new ObjectOutputStream(socket.getOutputStream());
    netOut.flush();
    netIn = new ObjectInputStream(socket.getInputStream());
    System.out.println("ClientSession " + this + " starts...");
    while (true) {
        Object nameMsg = null;
        try {
            nameMsg = netIn.readObject();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (nameMsg instanceof NameMessage) {
            this.setName(((NameMessage) nameMsg).name);
            break;
        }
    }
    start();
}

public void run() {
    try {
        activeSessions.addSession(this);
        while (true) {
            Object inMsg = null;
            try {
                try {
                    inMsg = netIn.readObject();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (inMsg instanceof ReadyMessage) {
                ready = true;
            } else if (inMsg instanceof DirMessage) {
                p.setDir(((DirMessage)inMsg).dir);
            }

        }
    } finally {
        try {
            socket.close();
        } catch (IOException e) {
        }
    }
}

public void sendMessage(Message msg) {
    try {
        if (!socket.isClosed()) {
            netOut.writeObject(msg);
            netOut.flush();
        } else {
            throw new IOException();
        }
    } catch (IOException eee) {
        try {
            socket.close();
        } catch (IOException ee) {
        }
    }
}

在客户端创建输入和输出：

public void connect() {
    try {
        InetAddress serverAddr = InetAddress.getByName(serverName);
        try {
            System.out.println("Connecting with "
                    + serverAddr.getHostName() + ":" + port);
            socket = new Socket(serverAddr, port);

            try {
                System.out.println("Connected to "
                        + serverAddr.getHostName());
                netOut = new ObjectOutputStream(socket.getOutputStream());
                netOut.flush();
                netIn = new ObjectInputStream(socket.getInputStream());
                netOut.writeObject(new NameMessage(name));
                netOut.flush();
            } finally {

            }

        } catch (ConnectException e) {
            System.out.println("Cannot connect to server");

        } catch (IOException e) {
            System.out.println("Input error");
        }

    } catch (UnknownHostException e) {
        System.out.println("Unknown server: " + e.getMessage());
    }
}

客户端接收器：

public void run() {
    while (true) {
        Object a = null;

            try {
                a = netIn.readObject();
                netIn.reset();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        if (a != null && a instanceof CoordMessage) {
            setXY((CoordMessage)a);
        }
    }
}

堆栈跟踪：

java.io.StreamCorruptedException: invalid type code: 00
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readObject(Unknown Source)
at twoPlayerClient.Receiver.run(Receiver.java:28)

在创建输入和输出之后，我继续将它们传递给其他类，而不是创建新类

我读过其他类似的问题，但找不到为什么会发生这种情况的答案

 new ClientSession(sock, outQueue, activeSessions);

---

我认为，每个客户端都有一个新的会话，因此不能使用具有全局范围的流变量。因为它也被其他会话线程使用

请参阅，而不是像它看起来那样，您不应该在

ClientSession

的构造函数中执行任何I/O操作，包括构造流。您必须在run（）方法中完成这一切。否则，您将阻塞accept（）循环，这将对其他客户端产生不利影响<

ObjectInputStream

不支持代码>重置。创建流后无需直接刷新（虽然不会造成任何伤害）。除此之外，我建议进行单元测试（并提高代码质量，以便进行单元测试）。我通过只从服务器发送对象和客户端发送符合我需要的字符串来解决这个问题。