Java服务器结构

目前我的java服务器工作正常，将所有客户端存储在一个新线程上，但性能不太好

我的主服务器类

public class MainServer {

    private ServerSocket server;

    public MainServer(int port) {

        try {

            server = new ServerSocket(port);
            System.out.println("Server started on port " + port + "...");
            ServerLoop();

        } catch (IOException e) {

            System.out.println("[ERROR] Server cannot be started on port " + port + "...");
        }
    }

    public void ServerLoop() {

        Thread serverLoop = new Thread(new Runnable() {

            public void run() {

                ServerDispatcher dispatcher = new ServerDispatcher();

                while (true) {

                    try {

                        Socket connectedClient = server.accept();
                        dispatcher.connectedClients.add(connectedClient);
                        System.out.println("Client number - " + dispatcher.connectedClients.size() + " connected...");
                        Thread clientThread = new Thread(new ClientHandler(connectedClient, dispatcher));
                        clientThread.start();

                    } catch (IOException e) {

                        e.printStackTrace();
                    }
                }
            }
        });

        serverLoop.start();
    }
}

因此，这部分将为每个客户机启动一个新线程，并将客户机添加到dispatcher客户机列表中

ClientHandler类

public class ClientHandler implements Runnable {

    private Socket currentClient;
    private ServerDispatcher handler;

    public ClientHandler(Socket s, ServerDispatcher dispatcher) {

        currentClient = s;
        handler = dispatcher;
    }

    public void run() {



        while (true) {


        }


    }
}

这是我的ServerDispatcher类

public class ServerDispatcher {

    public ArrayList<Socket> connectedClients;

    public ServerDispatcher() {

        connectedClients = new ArrayList<Socket>();
        CheckClients();
    }

    public void CheckClients() {

        Thread checkClients = new Thread(new Runnable() {

            public void run() {

                while (true) {

                    Integer clientSize = connectedClients.size();

                    if (!clientSize.equals(0)) {

                        for (int i = 0; i < connectedClients.size(); i++) {

                            try {

                                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(connectedClients.get(i).getOutputStream()));
                                writer.write("1");
                                writer.flush();
                                //System.out.println("Checking");

                            } catch (IOException e) {

                                int clientNumber = i + 1;
                                System.out.println("Client number - " + clientNumber + " disconnected...");
                                connectedClients.remove(i);
                            }
                        }
                    }
                }
            }
        });

        checkClients.start();
    }
}

公共类服务器调度器{
公共ArrayList ConnectedClient；
公共服务器调度程序（）{
connectedClients=newarraylist（）；
CheckClients（）；
}
公共void CheckClients（）{
线程checkClients=新线程（newrunnable（）{
公开募捐{
while（true）{
整数clientSize=connectedClients.size（）；
如果（！clientSize.equals（0））{
对于（int i=0；i

这会检查所有在线客户端

问题是这个服务器在执行时使用了67%的CPU，如何改进代码？也许从ServerDispatcher中删除所有线程，而只保留客户端线程

---

还有一个问题：我想在我的while循环中向X客户端发送一条消息，但有一次，我在google上查看了一下，似乎LinkedBlockingQueue就是我要找的，但我找不到任何易于实现的教程。

你的循环只会尽可能快地发送数据，如果不能，则会忙着等待。这必然会占用大量的CPU。一个简单的解决方案是只定期发送伪数据（因为实际上根本不需要发送）

我建议加上

Thread.sleep(100);

到发送循环，CPU应该下降到1%左右

---

你还可以做一些其他的改进，但没有一个比这更重要。

这可能是什么原因造成的吗？好吧，我真的需要，如果是这样的话，保持服务器上的客户端连接，我想，（不是吗？）TCP协议保持连接，而你不需要发送任何东西。