服务器队列/限制

Question

我有一个服务器/客户端程序，我已经为一个简单的猜谜游戏编写了程序，我这样做是为了在游戏开始之前必须连接至少3个客户端。我有一个多线程服务器，可以一次处理多个客户端，iv还尝试编写一个循环，如果语句试图在没有启动3个服务器线程的情况下停止游戏运行，但我似乎无法使其正常工作。

我的Server.java

import java.net.*;
import java.util.ArrayList;

public class Server {

    public static ArrayList<ServerClientThread> list = new ArrayList<>();
    public static void main(String[] args) throws Exception {
        try {
            ServerSocket server = new ServerSocket(8888);
            int counter = 0;
            System.out.println("Server Running...");
            while (true) {
                if (list.size() < 3) {
                    counter++;
                    Socket serverClient = server.accept();
                    ServerClientThread th = new ServerClientThread(serverClient, counter);
                    th.start();
                    Thread.sleep(100);
                    list.add(th);
                    System.out.println(th.clientName + " Joined!");
                }
                for (int a = 0; a < list.size(); a++) { 
                    if(!list.get(a).isAlive()){
                        list.remove(a);
                    }
                }
            }
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

我的Player.java（客户端）：

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

public class Player {

    public static void main(String[] args) throws Exception {
        String play = "p";
        Scanner in = new Scanner(System.in);
        System.out.print("Enter Your Name: ");
        String name = in.next();
        while (true) {
            try {
                Socket socket = new Socket("127.0.0.1", 8888);
                DataInputStream inStream = new DataInputStream(socket.getInputStream());
                DataOutputStream outStream = new DataOutputStream(socket.getOutputStream());
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                String clientMessage = "", serverMessage = "";
                outStream.writeUTF(name);
                outStream.flush();

                while (true) {
                    System.out.print("Enter number :");
                    clientMessage = br.readLine();
                    outStream.writeUTF(clientMessage);
                    outStream.flush();
                    if (clientMessage.equals("q") || clientMessage.equals("e")) {
                        break;
                    }
                    serverMessage = inStream.readUTF();
                    System.out.println(serverMessage);
                    if (serverMessage.equals("Congratulations!") || serverMessage.split("\n")[0].equals("Your Guesses Limit is Reached.")) {
                        break;
                    }
                }
                outStream.close();
                outStream.close();
                socket.close();
            } catch (Exception e) {
                System.out.println(e);
            }
            System.out.print("Wanna Play Again?<p-play, q-quit>: ");
            play = in.next();
            if(play.equals("q")){
                System.exit(0);
            }
        }
    }
}

我的ServerClientThread.java

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;


public class ServerClientThread extends Thread {

    Socket serverClient;
    int clientNo;
    int guesses;
    int number;
    String clientName;

    ServerClientThread(Socket inSocket, int clientNo) {
        serverClient = inSocket;
        this.clientNo = clientNo;
        guesses = 0;
        number = new Random().nextInt(12 - 0) + 0;
    }

    public void run() {
        try {
            DataInputStream inStream = new DataInputStream(serverClient.getInputStream());
            DataOutputStream outStream = new DataOutputStream(serverClient.getOutputStream());
            String clientMessage = "", serverMessage = "";
            clientName = inStream.readUTF();

            while (true) {
                clientMessage = inStream.readUTF();
                if(clientMessage.equals("q") || clientMessage.equals("e")){
                    break;
                }
                int guess = Integer.parseInt(clientMessage);
                if(guess == number){
                    guesses++;
                    serverMessage = "Congratulations!";
                }
                else if(guess < number){
                    guesses++;
                    serverMessage = "Your Number is Smaller than the Generated Number";
                }
                if(guess > number){
                    guesses++;
                    serverMessage = "Your Number is Bigger than the Generated Number";
                }
                if(guesses == 4){
                    serverMessage = "Your Guesses Limit is Reached.\nNumber was: "+number;
                }
                outStream.writeUTF(serverMessage);
                outStream.flush();
                if(guesses == 4){
                    break;
                }
            }
            inStream.close();
            outStream.close();
            serverClient.close();
        } catch (Exception ex) {
            System.out.println(ex);
        }
    }
}

Answer 1

听起来您需要使用CountdownLatch。您每次客户连接时都会递减计数，计数完成后（3位客户之后）便可以开始使用。

here是有关如何使用它的示例的文章。

Link到Javadocs。