双向多线程套接字连接

Question

The situation is as following: There is a server and a client, which both can initiate a command/message to each other.

Because the server can send a message at any time, the listening on the socket is done in a separate thread (a ListenerThread ). This is all fine. The client can send messages and receive at the same time, however, how would you know if a certain response belongs to the command you sent when the server can also initiate a new command/message to notify that something happened?

If I send a message to the server, and the server responds with "OK" in the listening thread. How would you know this is the actual response of the message/command you sent (keeping in mind this is another thread). What if the server received an update from another client and sends that update first.

This like a chat application, though with an actual response for every sent command.

example case:

Let us say that the protocol only consists of a move <playernum> [<x>,<y>] command which indicates that a player has done a move (server notifies client) or that a player wants to do a move (client notifies server). Also, the server responds with "OK" if the move was okay or with "ERR" if not.

Safe state:

     move 1 [3,4]
client ---> server

        OK
client <--- server

Unsafe state:

    move 1 [3,4]
client ---> server

    move 2 [1,2]
client <--- server

        OK
client <--- server

The client did not expect this response... should responded with OK.

Answer 1

You have a protocol where the client can read one of three possible messages:

1. OK (The move you made was accepted)
2. ERR (The move you made was rejected)
3. move PLAYERID <co-ord1,co-ord2>

It is a reasonable assumption that the messages OK and ERR will only be sent back to the socket which requested a move . However a legal move is broadcast to all other players (perhaps excluding the player who moved).

Since you can receive unsolicited responses (the moves that other players make), you have correctly created a listener thread. You have not described the action your application takes when it receives a move message from another client, but I will assume that your listener thread handles that case. What remains is how to co-ordinate your move commands, and the response to that which will appear in the listener thread.

To synchronize the submission of your move command, and the response, a BlockingQueue (called queue ) will be used , and shared between the client and listener. The form of this will be:

Client:

out.println(command);   // Where out is the socket PrintWriter stream
String response = queue.take();   // Where queue is the BlockingQueue
// Process either `OK` or `ERR`

Listener Thread:

while ((command = in.readLine()) != null) {
    if (command.equalsIgnoreCase("OK") || command.equalsIgnoreCase("ERR"))
        queue.put(command);
    else if (command.startsWith("move")) {
        // Process a move
    }
    else 
        System.out.println("Unrecognized command="+command);
}

As you can see, the client simply submits a command, and blocks for the response of "OK" or "ERR". The requirement for processing other player moves has moved into the listener thread.

The listener processes all three conditions (Another player move, an "OK" or an "ERR"). The messages responses "OK" and "ERR" are sent back to the client. A move command is processed separately, and as such is not the responsibility of the client making the moves.

Below I have mocked working code which demonstrates these concepts. The server will randomly (with equal probability) respond with:

1. OK
2. ERR
3. A multiline response which includes OK and another player's move

Code:

public class MoveGame {

public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);
    String command = "";

    new Thread(new MoveServer()).start();

    Socket socket = null;
    PrintWriter out = null;
    BlockingQueue<String> queue = new ArrayBlockingQueue<String>(10);
    try {
        socket = new Socket("localhost", 5001);
        out = new PrintWriter(socket.getOutputStream(), true);
        new Thread(new ClientReader(socket, queue)).start();

        while (!command.equals("quit")) {

            command = scanner.nextLine();
            if (command.startsWith("move")) {
                out.println(command);
                String response = queue.take();
                System.out.println("Client got response="+response);
            }
        }

    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        scanner.close();
        out.close();
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

static class ClientReader implements Runnable {

    private final Socket socket;
    private final BlockingQueue<String> queue;
    public ClientReader(Socket socket, BlockingQueue<String> queue) {
        super();
        this.socket = socket;
        this.queue = queue;
    }

    @Override
    public void run() {
        BufferedReader in = null;
        try {
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String command;
            while ((command = in.readLine()) != null) {
                if (command.equalsIgnoreCase("OK") || command.equalsIgnoreCase("ERR"))
                    queue.put(command);
                else if (command.startsWith("move")) {
                    System.out.println("A player made a move: command="+command);
                }
                else 
                    System.out.println("Unrecognized command="+command);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

static class MoveServer implements Runnable {

    @Override
    public void run() {

        Random random = new Random();
        Socket socket = null;
        try {
            ServerSocket ss = new ServerSocket(5001);
            while (true) {

                System.out.println("Listening for new connections");
                socket = ss.accept();
                System.out.println("New session has started");
                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                String command;
                while ((command = in.readLine()) != null) {
                    System.out.println("Got command="+command);
                    int responseType = random.nextInt(3);
                    if (responseType == 0) 
                        out.println("OK");
                    else if (responseType == 1)
                        out.println("ERR");
                    else {
                        out.println("move 1 [3,4]");
                        out.println("OK");
                    }
                }
                in.close();
                out.close();
                socket.close();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

}