Java ServerSocket，如何每次接受2个连接？

Question

I'm currently developing a TicTacToe multithreaded networked game for my university and I'm stuck on an annoying problem.

I wish that my server accepts 2 connections each time and then waits for other 2 connections etc.

The problem is that, in my code, if a client connects to the server and closes the connection while the second client is not yet connected to the server, the second client is not able to play because it "thinks" that the first client is connected and ready.

I thought to do something like this but I can't find a way to actually implement it.

The server is structured in 3 classes:

• TTT_Server (which cointains the main method and launches threads);
• TTT_ServerThread (which contains the thread(s) behaviour);
• TTT (which contains the TicTacToe board and some method).

TTT_Server class:

    public class TTT_Server()
    {
    private static ServerSocket serverSocket;
    private static boolean running = true;


    public static void main(String[] args)
    {
        try
        {
            // creazione ServerSocket sulla porta 8089
            serverSocket = new ServerSocket(8089);
            System.out.println("Server Socket creata e in ascolto sulla porta 8089");

            while(running)
            {
                TTT ttt = new TTT();
                Socket socket1 = serverSocket.accept();
                Socket socket2 = serverSocket.accept();
                TTT_ServerThread st1 = new TTT_ServerThread(socket1, 1, ttt, socket2);
                TTT_ServerThread st2 = new TTT_ServerThread(socket2, 2, ttt, socket1);
                st1.start();
                st2.start();
                System.out.println("thread lanciati");
            }

        }
        catch(IOException e)
        {
            System.out.println(e);
            running = false;
        }
        finally
        {
            try
            {
                serverSocket.close();
            }
            catch (IOException e)
            {
                System.out.println(e);
            }
        }
    }
}

(a part of) TTT_ServerThread class:

private Socket socket;
private Socket socketOtherPlayer;

private BufferedReader in;
private PrintWriter out;
private PrintWriter outOtherPlayer;

private TTT TicTacToe;

private int player;
private boolean fineGioco;
private int counter = 0;

public TTT_ServerThread(Socket socket, int num_connessione, TTT ttt, Socket socketOtherPlayer)
{
    this.socket = socket;
    this.socketOtherPlayer = socketOtherPlayer;
    this.player = num_connessione;
    this.TicTacToe = ttt;
    try
    {
        this.in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        this.out = new PrintWriter(socket.getOutputStream());
        this.outOtherPlayer= new PrintWriter(socketOtherPlayer.getOutputStream());
    }
    catch(IOException e)
    {
        System.out.println(e);
    }
}
@Override
public void run()
{
   //[...]
}

(a part of) TTT class:

public class TTT
{
private int[] board = new int[9];
private int turno = 1;

public TTT()
{
    for (int i = 0; i < 9; i++)
        board[i] = 0;
}

protected synchronized void setBoard(int locazioneMossa, int giocatore)
{
    board[locazioneMossa] = giocatore;
}

protected synchronized int getBoard(int locazioneMossa)
{   
    return board[locazioneMossa];
}

protected synchronized void setTurno(int turnoRicevuto)
{
    turno = turnoRicevuto;
}

protected synchronized int getTurno()
{
    return turno;
}
//[...]
}

Is there a way to implement a sort of that diagram that i thought?

Thank you all in advance for the help! And sorry for my English, it's not my primary language.

Answer 1

Instead of trying to "accept two connections at a time", you should accept one connection at a time. If there's no waiting connection, the connection should be put to a waiting list. If there is a waiting connection, pair them up.

That way you'll have a single accept() per loop, but 2 possible ways to handle them.