Java 如何使用相同的连接停止while循环的连续执行

我正在用Java为聊天应用程序制作一个服务器

while循环应该连接到新的客户机，但代码会重复连接到第一个客户机，即使在连接后，也会导致Bind Failed错误。我应该换什么

import java.io.*;
import java.net.*;
import java.util.Scanner;

public class ServerM
{   
    public static void main(String args[])
    {
        while(true)
        {
            Listener l = new Listener();
            l.run();
        }
    }

}

class Listener implements Runnable
{
    static InetAddress arr[] = new InetAddress[10];
    static int i = 0;

    public void run()
    {

        try
        {
            ServerSocket ss = new ServerSocket(44444);
            System.out.println("Waiting...");
            Socket s = ss.accept();
            System.out.println("Connected!\n");

            DataInputStream din=new DataInputStream(s.getInputStream());
            String ip = din.readUTF();

            InetAddress addr = InetAddress.getByName(ip);

            for(int j=0; j<=i; j++)
            {
                if(arr[j] == addr)
                    return;
            }

            arr[i++] = addr;

            ChatThread c = new ChatThread(addr,s);//This creates a thread to allow communication with Client
            c.run();

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

import java.io.*；
导入java.net。*；
导入java.util.Scanner；
公共类服务器
{   
公共静态void main（字符串参数[]）
{
while（true）
{
Listener l=新的Listener（）；
l、 run（）；
}
}
}
类侦听器实现可运行
{
静态InetAddress arr[]=新的InetAddress[10]；
静态int i=0；
公开募捐
{
尝试
{
ServerSocket ss=新的ServerSocket（44444）；
System.out.println（“等待…”）；
套接字s=ss.accept（）；
System.out.println（“已连接！\n”）；
DataInputStream din=新的DataInputStream（s.getInputStream（））；
字符串ip=din.readUTF（）；
InetAddress addr=InetAddress.getByName（ip）；
对于（int j=0；j您的问题在于解决方案的设计。您正在运行服务器套接字的多个实例（并且使用相同的端口，以异常结束），并使用此线程获取客户端连接，因此您只能有一个连接

您应该做的是，为将侦听所有连接的服务器套接字运行一个线程，然后在无限循环中运行每个客户端实例（新线程）

public class ServerM
{   
    public static void main(String args[])
    {

        Listener l = new Listener();
        l.run();

    }

}

class Listener implements Runnable
{
    static InetAddress arr[] = new InetAddress[10];
    static int i = 0;

    public void run()
    {

        try
        {
            ServerSocket ss = new ServerSocket(44444);
            System.out.println("Waiting...");
            while (true) {
                Socket s = ss.accept();
                ClientListener clientListener = new ClientListener(s);
                clientListener.run();
            }

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

class ClientListener implements Runnable {

    private Socket socket;

    public ClientListener(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        System.out.println("Connected!\n");

        DataInputStream din=new DataInputStream(s.getInputStream());
        String ip = din.readUTF();

        InetAddress addr = InetAddress.getByName(ip);

        for(int j=0; j<=i; j++)
        {
            if(arr[j] == addr)
                return;
        }

        arr[i++] = addr;

        ChatThread c = new ChatThread(addr,socket);
        c.run();
    }

}

公共类服务器
{   
公共静态void main（字符串参数[]）
{
Listener l=新的Listener（）；
l、 run（）；
}
}
类侦听器实现可运行
{
静态InetAddress arr[]=新的InetAddress[10]；
静态int i=0；
公开募捐
{
尝试
{
ServerSocket ss=新的ServerSocket（44444）；
System.out.println（“等待…”）；
while（true）{
套接字s=ss.accept（）；
ClientListener ClientListener=新的ClientListener；
clientListener.run（）；
}
}
捕获（例外e）
{
e、 printStackTrace（）；
}
}
}
类ClientListener实现Runnable{
专用插座；
公共ClientListener（套接字）{
this.socket=socket；
}
公开募捐{
System.out.println（“已连接！\n”）；
DataInputStream din=新的DataInputStream（s.getInputStream（））；
字符串ip=din.readUTF（）；
InetAddress addr=InetAddress.getByName（ip）；
对于（int j=0；j您的问题在于解决方案的设计。您正在运行服务器套接字的多个实例（并且使用相同的端口，以异常结束），并使用此线程获取客户端连接，因此您只能有一个连接

您应该做的是，为将侦听所有连接的服务器套接字运行一个线程，然后在无限循环中运行每个客户端实例（新线程）

public class ServerM
{   
    public static void main(String args[])
    {

        Listener l = new Listener();
        l.run();

    }

}

class Listener implements Runnable
{
    static InetAddress arr[] = new InetAddress[10];
    static int i = 0;

    public void run()
    {

        try
        {
            ServerSocket ss = new ServerSocket(44444);
            System.out.println("Waiting...");
            while (true) {
                Socket s = ss.accept();
                ClientListener clientListener = new ClientListener(s);
                clientListener.run();
            }

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}

class ClientListener implements Runnable {

    private Socket socket;

    public ClientListener(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        System.out.println("Connected!\n");

        DataInputStream din=new DataInputStream(s.getInputStream());
        String ip = din.readUTF();

        InetAddress addr = InetAddress.getByName(ip);

        for(int j=0; j<=i; j++)
        {
            if(arr[j] == addr)
                return;
        }

        arr[i++] = addr;

        ChatThread c = new ChatThread(addr,socket);
        c.run();
    }

}

公共类服务器
{   
公共静态void main（字符串参数[]）
{
Listener l=新的Listener（）；
l、 run（）；
}
}
类侦听器实现可运行
{
静态InetAddress arr[]=新的InetAddress[10]；
静态int i=0；
公开募捐
{
尝试
{
ServerSocket ss=新的ServerSocket（44444）；
System.out.println（“等待…”）；
while（true）{
套接字s=ss.accept（）；
ClientListener ClientListener=新的ClientListener；
clientListener.run（）；
}
}
捕获（例外e）
{
e、 printStackTrace（）；
}
}
}
类ClientListener实现Runnable{
专用插座；
公共ClientListener（套接字）{
this.socket=socket；
}
公开募捐{
System.out.println（“已连接！\n”）；
DataInputStream din=新的DataInputStream（s.getInputStream（））；
字符串ip=din.readUTF（）；
InetAddress addr=InetAddress.getByName（ip）；
对于（intj=0；jCatch异常是不好的做法

 catch(Exception e)
    {
        e.printStackTrace();
    }

尝试将自定义异常（MyException.class）转发到顶层，并在Try..catch.中的ServerM类中处理此异常，并且不要忘记在finally块中关闭套接字

ss.close();
s.close();

捕获例外是不好的做法

 catch(Exception e)
    {
        e.printStackTrace();
    }

尝试将自定义异常（MyException.class）转发到顶层，并在Try..catch.中的ServerM类中处理此异常，并且不要忘记在finally块中关闭套接字

ss.close();
s.close();