Thread: When you have a multi-threaded Server and Client program....

...how exactly do you ensure that the Server always sends the data after the Client has entered a wait state for the data?

As in, if I have the Server write something and the Client read something from the server, how do I always ensure that the Server didn't write before the server began waiting to read?

The lazy solution is to have the thread in the server sleep for 2000 ms or so before it sends across the data, so that you can pretty much guarantee that by the time those 2000 ms are up the Client would have reached the "ready to read data from the server" stage.

But that's a crappy solution. How exactly is this kind of stuff handled?

Yes, but the code is kind of complicated. I'll try to give a brief version here.

The Client is playing a game. He connects to the server, and the server executes the game and gives the client whatever information he needs to know about what's happening in the game.

In this example, the Server is telling the Client that the game is over.

After telling the Client that the game is over, the Server wants to tell the Client who won. He then sends "gameResults", which is a String saying who won, or if it was a draw, etc.

So,
1.) The client is waiting for some message from the server. He's just sitting there waiting.
2.) Since the game is now over, the Server says "game over" to the server.
3.) The client receives it, and, since the game is over, he now needs to know who won or whether it was a draw, or what.
4.) The client begins waiting
4.) The server sends the "gameResults" to the client

We have two step fours. How do I ensure that the client begins waiting before the server sends the information?


Server code

                        try
                        {
                                outputToClient.writeBytes("Game over\n");
 
                                try
                                {
                                        Thread.sleep(2500);
 
                                } catch (InterruptedException ex)
                                {
                                        System.out.println(ex);
                                }
 
                                outputToClient.writeBytes(gameResults() + "\n");
 
                                sock.close();
 
                        } catch (IOException ex)
                        {
                                System.err.println(ex);
                        }

Client code

             while(gameInProgress)
		{
			try
			{	
				processMessage(d.readLine());
 
			} catch (IOException ex)
			{
				System.err.println(ex);
			}
		}	
 
	}
 
	public void processMessage(String message)
	{
		if (message.equals("Valid move."))
		{
			System.out.println("Valid move, please wait.");
 
			setSymbol(location, mySymbol); 
			board.printBoard();
		}
		else if (message.equals("Invalid move."))
		{
			System.out.println(message);
			myTurn = true;
			board.printBoard();
			location = userInput.nextDouble();
 
			try
                        {
                                outToServer.writeDouble(location);
 
                        } catch (IOException ex)
                        {
                                System.err.println(ex);
                        }
 
		}
		else if (message.equals("Opponent moved"))
		{
			try
			{
				location = inpFromServer.readDouble();
 
			} catch (IOException ex)
			{
				System.err.println(ex);
			}
 
			setSymbol(location, opponentSymbol);
 
			board.printBoard();
 
			System.out.println("Opponent moved. Your turn.");
 
			location = userInput.nextDouble();
 
			try
			{
				outToServer.writeDouble(location);
 
			} catch (IOException ex)
			{
				System.err.println(ex);
			}
			myTurn = true;	
		}
		else if (message.equals("Game over"))
		{
			gameInProgress = false;
 
			BufferedReader b = null;
 
			try
			{
				b = new BufferedReader(new InputStreamReader(connection.getInputStream()));
 
				board.printBoard();
 
				System.out.println(b.readLine());
				connection.close();
 
			} catch (IOException ex)
			{
				System.err.println(ex);
			}
		}
		else
		{
			System.out.println("We don't understand the server's message: ' " + message + " ' ");
		}	
	}

I'm sorry...I don't understand what you mean.

All I have is the client saying "System.out.println(b.readLine());"

So, he's waiting for the Server.

But that's useless if the Server sends the data before the Client reaches that line of code.

I see what you're saying.

Here, though, the Server is kind of sending two messages in a row.

I suppose that's bad practice?

Well....what if the Server sends something, then in the next line of code sends another message.

Then the client receives the first message....has to do stuff with it...then, when it's done, the client is ready for the second message. But by then the server has already sent the message!!