多线程套接字服务器Java，连接重置SocketException

这是我的服务器类代码。

无效运行（）

然后我的客户端类：

public void run()
{
    try{
        //1. creating a socket to connect to the server
        requestSocket = new Socket(InetAddress.getLocalHost(), 2004);
        message = new Message();
        System.out.println("Connected to localhost in port 2004");
        //2. get Input and Output streams
        out = new ObjectOutputStream(requestSocket.getOutputStream());
        out.flush();
        in = new ObjectInputStream(requestSocket.getInputStream());
        //3: Communicating with the server
        do{
            try{

                message.status = "connected";

                message.actionUser.setUserID(1);
                message.actionUser.setPassword("bear");
                sendMessage(message);

                message = (Message)in.readObject();
                Object output = message.getProtocol().processInput(message);
                message.connect = false;
                message.status = "Disconnected";
                //sendMessage(message);
            }
            catch(Exception e){
                System.err.println("data received in unknown format");
                System.err.println(e.getMessage());
            }
        }while(message.connect);
    }
    catch(UnknownHostException unknownHost){
        System.err.println("You are trying to connect to an unknown host!");
    }
    catch(IOException ioException){
        ioException.printStackTrace();
    }
     finally{
        //4: Closing connection

            try{
                if(requestSocket.isInputShutdown())
                in.close();
                if(requestSocket.isOutputShutdown())
                out.close();
                requestSocket.close();
            }
            catch(IOException ioException){
                ioException.printStackTrace();
            }
         }

}

当我尝试多线程运行它们时，会出现这些错误。它一次只能工作一个线程，但在两个客户端线程运行时不能工作。 sendMessage只是writeObject（msg），其中msg是我试图发送的消息对象

来自客户端类的错误消息

Connected to localhost in port 2004
Connected to localhost in port 2004
client>connected
java.net.SocketException: Connection reset
    at java.net.SocketInputStream.read(Unknown Source)
    at java.net.SocketInputStream.read(Unknown Source)
    at java.io.ObjectInputStream$PeekInputStream.read(Unknown Source)
    at java.io.ObjectInputStream$PeekInputStream.readFully(Unknown Source)
    at java.io.ObjectInputStream$BlockDataInputStream.readShort(Unknown Source)
    at java.io.ObjectInputStream.readStreamHeader(Unknown Source)
    at java.io.ObjectInputStream.<init>(Unknown Source)
    at auction.Requester.run(Requester.java:22)
    at java.lang.Thread.run(Unknown Source)

已连接到端口2004中的本地主机
已在端口2004中连接到本地主机
客户端>已连接
java.net.SocketException:连接重置
位于java.net.SocketInputStream.read（未知源）
位于java.net.SocketInputStream.read（未知源）
位于java.io.ObjectInputStream$PeekInputStream.read（未知源）
在java.io.ObjectInputStream$PeekInputStream.readFully处（未知源）
位于java.io.ObjectInputStream$BlockDataInputStream.readShort（未知源）
位于java.io.ObjectInputStream.readStreamHeader（未知源）
位于java.io.ObjectInputStream。（未知源）
运行（Requester.java:22）
位于java.lang.Thread.run（未知源）

第一个线程在服务器上成功运行后，会出现以下情况： 从152.78.175.6收到的连接 客户端>已连接 有联系的 服务器>已连接 用户1已登录 正在等待连接

崩溃的行（22）为out=newObjectOutputStream（connection.getOutputStream（））

---

非常感谢您的帮助

您的服务器套接字不是多线程的。要处理多个客户端，您需要执行以下操作：

public class MultiThreadServer implements Runnable {
   Socket csocket;
   MultiThreadServer(Socket csocket) {
      this.csocket = csocket;
   }

   public static void main(String args[]) 
   throws Exception {
      ServerSocket ssock = new ServerSocket(1234);
      System.out.println("Listening");
      while (true) {
         Socket sock = ssock.accept();
         System.out.println("Connected");
         new Thread(new MultiThreadServer(sock)).start();
      }
   }
   public void run() {
      try {
         PrintStream pstream = new PrintStream
         (csocket.getOutputStream());

         // handle all input output here.

         pstream.close();
         csocket.close();
      }
      catch (IOException e) {
         System.out.println(e);
      }
   }
}

---

希望这有帮助。

使您的服务器成为多线程，这样它就可以在不同的线程中处理每个客户端

试试这个：

Class ConnectionThread extends Thread {

Socket connection;
ObjectInputStream in;
OjectOutputStream out;
Message message;

Connection Thread(Socket connection) {
    this.connection = connection;
}

void run() {
    try {
        System.out.println("Connection received from " + connection.getInetAddress().getHostName());
        out = new ObjectOutputStream(connection.getOutputStream());
        out.flush();
        in = new ObjectInputStream(connection.getInputStream());
        message = new Message();

        do{
            try{
                message = (Message)in.readObject();
                System.out.println("client>" + message.status);
                System.out.println(message.status);
                Protocol pro = new Protocol();
                message.setProtocol(pro);
                sendMessage(message);
                message.connect = false;
            } catch(ClassNotFoundException classnot){
                System.err.println("Data received in unknown format");
            }
        } while(message.connect);
    }
    catch(IOException ioException){
        ioException.printStackTrace();
    }
    finally{
        try{
            in.close();
            out.close();
            providerSocket.close();
        } catch(IOException ioException){
            ioException.printStackTrace();
        }
    }
}
void sendMessage(Message msg) {
    try{
        out.writeObject(msg);
        out.flush();
        System.out.println("server>" + msg.status);
    } catch(IOException ioException){
        ioException.printStackTrace();
    }
}

Class ConnectionThread extends Thread {

Socket connection;
ObjectInputStream in;
OjectOutputStream out;
Message message;

Connection Thread(Socket connection) {
    this.connection = connection;
}

void run() {
    try {
        System.out.println("Connection received from " + connection.getInetAddress().getHostName());
        out = new ObjectOutputStream(connection.getOutputStream());
        out.flush();
        in = new ObjectInputStream(connection.getInputStream());
        message = new Message();

        do{
            try{
                message = (Message)in.readObject();
                System.out.println("client>" + message.status);
                System.out.println(message.status);
                Protocol pro = new Protocol();
                message.setProtocol(pro);
                sendMessage(message);
                message.connect = false;
            } catch(ClassNotFoundException classnot){
                System.err.println("Data received in unknown format");
            }
        } while(message.connect);
    }
    catch(IOException ioException){
        ioException.printStackTrace();
    }
    finally{
        try{
            in.close();
            out.close();
            providerSocket.close();
        } catch(IOException ioException){
            ioException.printStackTrace();
        }
    }
}
void sendMessage(Message msg) {
    try{
        out.writeObject(msg);
        out.flush();
        System.out.println("server>" + msg.status);
    } catch(IOException ioException){
        ioException.printStackTrace();
    }
}