Question

客户端连接有效（我使用telnet），但是当我与任何客户端编写消息时都不会发生任何事情-即使是空字符（断开连接）的情况。我不明白为什么。我通过args []获得了容量和端口，然后启动了服务器。

我已经测试了一个更简单的版本，其中只有一台服务器可以处理一个客户端，并且它可以正常工作。

public class EchoClient extends Thread {
    EchoServerForPool serv;
    BufferedReader inchan;
    DataOutputStream outchan;
    Socket socket;
    int port;

    public EchoClient(EchoServerForPool serv) {
        // TODO Auto-generated constructor stub
        this.serv = serv;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        Socket s;
        while (true) {
            synchronized (this.serv) {
                if (this.serv.stillWaiting() == 0) {
                    try {
                        this.serv.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                s = this.serv.removeFirstSocket();
                serv.newConnect();
            }

            try {
                inchan = new BufferedReader(new InputStreamReader(s.getInputStream()));
                outchan = new DataOutputStream(s.getOutputStream());
                String message = inchan.readLine();
                if (message.equals("")) {
                    System.out.println("fin de connection");
                    break;
                }

                outchan.writeChars(message + "\n");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                try {
                    s.close();
                    synchronized (serv) {
                        serv.clientLeft();
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }
    }

    public class EchoServerForPool extends Thread {
        ArrayList<EchoClient> clients;
        ArrayList<Socket> sockets;
        Socket client;
        int nbLocalhost = 0;
        int capacity, port, nbConnectedClient, nbWaitingSocket;

        public EchoServerForPool(int capacity, int port) {
            // TODO Auto-generated constructor stub
            this.capacity = capacity;
            this.port = port;
            clients = new ArrayList<EchoClient>(capacity);
            sockets = new ArrayList<Socket>();
            for (int i = 0; i < clients.size(); i++) {
                EchoClient ec_i = new EchoClient(this);
                clients.add(ec_i);
                ec_i.start();
            }
        }

        public Socket removeFirstSocket() {
            Socket res = sockets.get(0);
            sockets.remove(0);
            return res;
        }

        public void newConnect() {
            nbConnectedClient++;
            nbWaitingSocket--;
        }

        public int stillWaiting() {
            return nbWaitingSocket;
        }

        public void clientLeft() {
            nbConnectedClient--;
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                ServerSocket serv = new ServerSocket(this.port);
                while (true) {
                    this.client = serv.accept();
                    synchronized (this) {
                        nbLocalhost++;
                        System.out.println(client.getInetAddress().getHostName() + "-" + nbLocalhost + " connected");
                        sockets.add(client);
                        nbWaitingSocket++;
                        notify();
                    }
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

public class EchoPoolThread {
    public static void main(String[] args) {
        int port = Integer.parseInt(args[0]);
        int capacity = Integer.parseInt(args[1]);
        EchoClient.EchoServerForPool serveur = new EchoClient.EchoServerForPool(capacity, port);
        System.out.println("start server");
        serveur.start();
    }
}

编辑：问题是我用clients.size（）进行了迭代，而不是容量，以填充我的客户列表。...

Answer 1

我对您的代码进行了一些重构，以找到可行的解决方案。您可以从那里创建一个池，现在客户端数量不受限制。

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Gianlu
 */
public class Main {
    public static void main(String[] args) {
        int port = Integer.parseInt(args[0]);
        int capacity = Integer.parseInt(args[1]);
        EchoServerForPool serveur = new EchoServerForPool(capacity, port);
        System.out.println("start server");
        serveur.start();
    }

    public static class EchoServerForPool extends Thread {
        private final int port;
        private final ExecutorService executor;
        private final ArrayList<EchoClient> clients;
        private int nbLocalhost = 0;

        public EchoServerForPool(int capacity, int port) {
            this.port = port;

            clients = new ArrayList<>();
            executor = Executors.newFixedThreadPool(capacity);
        }

        @Override
        public void run() {
            try {
                ServerSocket serv = new ServerSocket(this.port);

                while (true) {
                    Socket socket = serv.accept();
                    EchoClient client = new EchoClient(this, socket);
                    executor.submit(client);
                    clients.add(client);
                    nbLocalhost++;
                    System.out.println(socket.getInetAddress().getHostName() + "-" + nbLocalhost + " connected");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public void terminated(EchoClient client) {
            clients.remove(client);
        }
    }

    public static class EchoClient implements Runnable {
        private final EchoServerForPool pool;
        private final Socket socket;
        private final BufferedReader inchan;
        private final DataOutputStream outchan;

        public EchoClient(EchoServerForPool pool, Socket socket) throws IOException {
            this.pool = pool;
            this.socket = socket;
            this.inchan = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            this.outchan = new DataOutputStream(socket.getOutputStream());
        }

        @Override
        public void run() {
            try {
                while (true) {
                    String message = inchan.readLine();
                    if (message.equals("")) {
                        System.out.println("fin de connection");
                        break;
                    }

                    outchan.writeChars(message + "\n");
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            pool.terminated(this);
        }
    }
}

回显服务器，该服务器使用线程池处理客户端

1 个答案: