Java客户端服务器聊天应用程序正在获取Java.net.SocketException:套接字已关闭

我正在尝试为全局聊天创建一个简单的客户端-服务器应用程序。当从客户端退出连接时，我遇到以下错误

java.net.SocketException: Socket closed
at java.net.SocketInputStream.read(SocketInputStream.java:203)
at java.net.SocketInputStream.read(SocketInputStream.java:141)
at java.net.SocketInputStream.read(SocketInputStream.java:223)
at java.io.DataInputStream.readUnsignedShort(DataInputStream.java:337)
at java.io.DataInputStream.readUTF(DataInputStream.java:589)
at java.io.DataInputStream.readUTF(DataInputStream.java:564)
at ReadFromServer.run(ChatClient.java:25)

当客户端崩溃时，不使用

退出
此错误

java.io.EOFException
at java.io.DataInputStream.readUnsignedShort(DataInputStream.java:340)
at java.io.DataInputStream.readUTF(DataInputStream.java:589)
at java.io.DataInputStream.readUTF(DataInputStream.java:564)
at Clients.run(ChatServer.java:34)

ChatServer.java

import java.util.*;
import java.io.*;
import java.net.*;
class Clients extends Thread 
{
private static ArrayList<DataOutputStream> clientOutputStreams;
private DataInputStream dataInputStream;
private DataOutputStream dataOutputStream;
private Socket socket;
static
{
    clientOutputStreams=new ArrayList<>();
}
Clients(Socket socket)
{
    try
    {
        this.socket=socket;
        this.dataInputStream=new DataInputStream(socket.getInputStream());
        this.dataOutputStream=new DataOutputStream(socket.getOutputStream());
        clientOutputStreams.add(dataOutputStream);
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
}
public void run()
{
    try
    {
        try
        {
            String message=dataInputStream.readUTF();
            while(!message.equalsIgnoreCase("quit"))
            {
                for(DataOutputStream dis:clientOutputStreams)
                {
                    dis.writeUTF(message);
                }
                message=dataInputStream.readUTF();
            }
            Thread.currentThread().interrupt();
        }
        finally
        {
            dataInputStream.close();
            dataOutputStream.close();
            clientOutputStreams.remove(clientOutputStreams.indexOf(dataOutputStream));
            socket.close();
        }
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
}
}
public class ChatServer
{
    public static void main(String[] args)throws Exception
    {
    try
    {
        ServerSocket serverSocket=new ServerSocket(9000);
        while(true)
        {
            Socket s=serverSocket.accept();
            Clients client=new Clients(s);
            client.start();
        }
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
}
}

import java.util.*;
import java.io.*;
import java.net.*;
class ReadFromServer extends Thread
{
private DataInputStream readMessage;
ReadFromServer(Socket socket)
{
    try
    {
        this.readMessage=new DataInputStream(socket.getInputStream());
    }
    catch(Exception e)
    {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }
}
public void run()
{
    try
    {
        while(!Thread.currentThread().isInterrupted())
        {
            System.out.println(readMessage.readUTF());
        }
        readMessage.close();
        Thread.currentThread().interrupt();
        if(Thread.currentThread().isInterrupted())
            return;
    }
    catch(Exception e)
    {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }
}
}
class WriteToServer extends Thread
{
private DataOutputStream writeMessage;
private String clientName;
private Socket socket;
WriteToServer(Socket socket,String clientName)
{
    try
    {
        this.socket=socket;
        this.writeMessage=new DataOutputStream(socket.getOutputStream());
        this.clientName=clientName;
    }
    catch(Exception e)
    {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }
}
public void run()
{
    try
    {
        Scanner scanner=new Scanner(System.in);
        String message=scanner.nextLine();
        while(!message.equalsIgnoreCase("quit"))
        {
            writeMessage.writeUTF(clientName+":"+message);
            message=scanner.nextLine();
        }
        writeMessage.writeUTF(message);
        writeMessage.close();
        Thread.currentThread().interrupt();
        if(Thread.currentThread().isInterrupted())
            return;
    }
    catch(Exception e)
    {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }
}
}
public class ChatClient
{
public static void main(String[] args)
{
    try
    {
        Socket socket=new Socket("localhost",9000);
        try
        {
            System.out.print("Enter Your Name:");
            Scanner scanner=new Scanner(System.in);
            String clientName=scanner.nextLine();
            ReadFromServer rfs=new ReadFromServer(socket);
            WriteToServer wts=new WriteToServer(socket,clientName);
            wts.start();
            rfs.start();
            while(wts.isAlive());
            rfs.interrupt();
            System.out.println("End of Both Threads");
            //socket.close();
        }
        finally
        {
            socket.close();
        }
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
}
}

当InputStreamReader使用套接字时，如何处理套接字关闭的情况表示您在
writeMessage.close（）
处关闭了套接字，然后在
readMessage.readUTF（）处继续使用它。这是代码中的一个bug。您必须确定读线程和写线程中的哪些线程应该关闭，并且应该只关闭其中一个线程，而不是在另一个线程仍在运行时关闭

EOFException
正是在对等方已经关闭的连接上调用
readUTF（）
时应该想到的。捕获它并单独处理。
好的，但我如何处理它作为readMessage。readUTF（）一直在等待消息，即使在ReadFromServer的run函数结束时关闭流，循环也只在Exceptioner之后结束，
Catch（EOFEException exc）{break；}
如果您在循环中，如果超出了
中断
，则忽略该中断。不神秘。