Java多客户端聊天服务器

我是Java编程新手，正在尝试开发多客户端聊天服务器

以下是我的代码：

package Server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;

public class server implements Runnable{

    private List<ServerClient> clients = new ArrayList<ServerClient>();

//private String UID;
private int port;
private ServerSocket socket;
private Thread run, manage, send, receive;
private boolean running = false;
public int i=0;

    public server(int port){
//      this.UID = UID;
        this.port = port;
        try {
            socket = new ServerSocket(port);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        run = new Thread(this, "Server");
        run.start();
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        running = true;
        ManageClients();
        receive();
    }
    private void ManageClients(){
        manage = new Thread("Manage"){
            public void run(){
                while(running){
                    //managing
                }
            }
        };
        manage.start();
    }

    private void receive(){
        receive = new Thread("Receive"){
            public void run(){
                Socket S1 = null;
                try {
                    S1 = socket.accept();
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                while(running){

/*                  byte [] data = new byte[1024];
                    DatagramPacket packet = new DatagramPacket(data, data.length);
                    try {
                        socket.receive(packet);
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    String string = new String(packet.getData());
                    System.out.println(string);*/
/*                  BufferedReader br = null;
                    try {
                        br = new BufferedReader(new InputStreamReader(S1.getInputStream()));
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    try {
                        String string = br.readLine();
                        System.out.println(string);
                        process(string);
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }*/
                    process(S1);
                    System.out.println(String.valueOf(i));
                    i++;
                }
            }
        };
        receive.start();
    }
    private void process(Socket S1){
        BufferedReader br = null;
        String string = "";
        try {
            br = new BufferedReader(new InputStreamReader(S1.getInputStream()));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            string = br.readLine();
            System.out.println(string);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        if(string.startsWith("/c/")){
            clients.add(new ServerClient("name", S1.getInetAddress(), S1.getPort(), "UID"));
        }
        else if(string.startsWith("/ip/")){
            //send ip address to raspberry
            System.out.println(string);
        }
        else if(string.startsWith("/r/")){
            //send relay command to relay
            System.out.println(string);
        }
    }
}

包服务器；
导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.net.DatagramPacket；
导入java.net.DatagramSocket；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.net.SocketException；
导入java.util.ArrayList；
导入java.util.List；
公共类服务器实现可运行{
private List clients=new ArrayList（）；
//私有字符串UID；
专用int端口；
专用服务器插座；
私有线程运行、管理、发送、接收；
私有布尔运行=false；
公共整数i=0；
公共服务器（int端口）{
//this.UID=UID；
this.port=端口；
试一试{
套接字=新服务器套接字（端口）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
运行=新线程（此“服务器”）；
run.start（）；
}
@凌驾
公开募捐{
//TODO自动生成的方法存根
运行=真；
ManageClients（）；
接收（）；
}
私有void ManageClients（）{
管理=新线程（“管理”）{
公开募捐{
（跑步时）{
//管理
}
}
};
manage.start（）；
}
私有无效接收（）{
接收=新线程（“接收”）{
公开募捐{
套接字S1=null；
试一试{
S1=socket.accept（）；
}捕获（IOE1异常）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
（跑步时）{
/*字节[]数据=新字节[1024]；
DatagramPacket数据包=新的DatagramPacket（数据，数据.长度）；
试一试{
套接字接收（数据包）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
String String=新字符串（packet.getData（））；
System.out.println（字符串）*/
/*BufferedReader br=null；
试一试{
br=新的BufferedReader（新的InputStreamReader（S1.getInputStream（））；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
试一试{
String String=br.readLine（）；
System.out.println（字符串）；
进程（字符串）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}*/
过程（S1）；
System.out.println（String.valueOf（i））；
i++；
}
}
};
receive.start（）；
}
私有无效进程（套接字S1）{
BufferedReader br=null；
字符串=”；
试一试{
br=新的BufferedReader（新的InputStreamReader（S1.getInputStream（））；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
试一试{
string=br.readLine（）；
System.out.println（字符串）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
if（string.startsWith（“/c/”）{
添加（新服务器客户端（“名称”，S1.getInetAddress（），S1.getPort（），“UID”）；
}
else if（string.startsWith（“/ip/”）{
//向raspberry发送ip地址
System.out.println（字符串）；
}
else if（string.startsWith（“/r/”）{
//向中继发送中继命令
System.out.println（字符串）；
}
}
}

服务器仅接受一个连接。如果我尝试连接另一个用户，控制台不会显示任何输出

你能告诉我哪里出了问题吗

---

谢谢

您需要多次运行

accept

方法。。。对于每个要连接的客户端一次。通常，人们在

循环中的一个单独线程上执行该操作，而
循环中的
accept
方法是阻塞的

在您的代码中，您似乎只调用了一次
accept
，因此您只能获得一个客户端连接

我建议您在这里更改代码体系结构，但如果您希望保持不变，并且您知道将连接多少个客户端，那么您可以将对套接字的访问封装在一个同步锁中，并为每个客户端调用一次
receive
方法。
这是一个非常广泛的问题，缺乏细节和细节。