Question

正如标题所示，我正在实施一个小项目，允许客户端使用多线程连接到服务器来管理连接。我想限制连接，当服务器满了请求时，其他客户端应该被放入队列，例如：服务器只允许2个客户端同时连接服务器，其他客户端直到轮到他们。

这是我的服务器类

public class Server {

    static BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
    //Declare an instance of CommandParameter class

    static CommandParameter par;
    //Initialize a BufferedReader and BufferedWriter
    static BufferedReader bufferedReader;
    static BufferedWriter bufferWriter;
    //
    static int port;
    static String serverData;
    static int proc_count;
    private static String command;

    public static void main(String[] args) throws Exception {
        command = userInput.readLine();
        System.out.println("Server is available");
        //Thread.sleep(2000);
        processCommand(command);
        startServer(port);

    }

    public static void startServer(int port) {
        ServerSocket serverSocket = null;
        try {
            //create a port for server in order to listen incoming connections
            serverSocket = new ServerSocket(port);
            //allow client connect to server

        } catch (IOException e) {
            System.out.println(e);
        }
        while (true) {
            try {
                new ThreadSocket(serverSocket.accept(),serverData).start();

            } catch (IOException ex) {
                System.out.println("Server starts fail");
            }
        }
    }

    public static void processCommand(String input) {
        //assign the user input to an String array
        String inputLine = input;
        int commandCount = checkCommand(inputLine);
        if(commandCount>3 || commandCount ==-1){
            System.out.println("Invalid command");
            System.exit(1);
        }
        //assign the user input to an String array
        String[] command = inputLine.split(" ");
        par = new CommandParameter();

        //JCommander parses the command to get the pairs parameter name and value
        JCommander jc = new JCommander(par, command);
        port = par.getPort();
        serverData = par.getServerdata();
        proc_count = par.getProc_count();
    }
    public static int checkCommand(String inputLine) {
        int count = 0;
        if (inputLine.contains("-port")) {
            count++;
        }else if (inputLine.contains("-data")) {
            count++;
        } else if (inputLine.contains("-proc_count")) {
            count++;
        } else{
            return -1;
        }

        return count;
    }
}

任何想法？

Answer 1

这正是异步IO变得最有用的地方。 [大量的IO请求需要由有限数量的工作线程处理]。大多数现代操作系统都有系统调用，允许异步IO操作。例如，linux中的epoll，Windows中的IOCP，AIX和Solaris，BSD版本的KQueue和Mac OS。在java中，本地非阻塞调用被抽象在不同的SPI后面 - 例如 - sun.nio.ch.WindowsSelectorImpl，sun.nio.ch.KQueueSelectorImpl，sun.nio.ch.EPollSelectorImpl等。

我建议您使用的是Netty。

使用较小固定数量的线程为大量HTTP请求提供服务的示例是使用netty API的一项简单任务。

带有一个侦听器线程和两个worker的示例引导代码看起来像

public static void setupHTTPListeners()
{
    ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(Executors.newFixedThreadPool(1),
    Executors.newFixedThreadPool(2)));
    -----
    -----
}

在相同的上下文中，最流行的读物之一就在这里 - The C10k problem。

Answer 2

使用ServerSocket(int port, int backlog); backlog参数是允许的最大连接数。

如何处理客户端 - 服务器Java应用程序中的线程数？

2 个答案: