We Keep Coding

Performance issues Once more than one client has connect to server

I am currently working on a multiplayer java game. To allow multiple clients to play at the same time I have created a DatagramSocket server.
The "protocol" for my server works something like this:
Client send update to server.
Server receives update.
Server creates a new thread to process the update.
The new thread sends a packet back to the client containing what needs to be rendered.
The 4th step is achieved by using the following method:
public void sendBack(InetSocketAddress address, ArrayList<RenderEntity> renderEntities) {
Player p = this.clients.get(address);
RenderPacket packet = new RenderPacket(renderEntities, p.getX(), p.getY());
this.byteBuffer = packet.getBytes();
DatagramPacket sendPacket = new DatagramPacket(this.byteBuffer, this.byteBuffer.length, address.getAddress(), address.getPort());
try {
this.socket.send(sendPacket);
} catch (IOException e) {
e.printStackTrace();
}
}
This "protocol" works relatively well from what I have tested on my own machine, but from what I have seen online the 4th step of my "protocol" is unconventional. Once an update has been received a packet containing what needs to be rendered is sent to all of the clients connected to the server as apposed to just the client that sent the update.
To try and implement this change I tried using the following method:
public void sendToAll(ArrayList<RenderEntity> renderEntities) {
try {
for (InetSocketAddress address : this.clients.keySet()) {
Player p = this.clients.get(address);
RenderPacket packet = new RenderPacket(renderEntities, p.getX(), p.getY());
byte[] data = packet.getBytes();
DatagramPacket sendPacket = new DatagramPacket(data, data.length, address.getAddress(), address.getPort());
this.socket.send(sendPacket);
}
} catch (IOException e) {
e.printStackTrace();
}
}
The sendToAll(renderEntities) method works great when just one client is connect but as soon as another client connects the client experiences many performance issues and I don't know why. I believe that the the problem is not related to the server because it is still able to communicate with the clients.
What are some possible reasons as to why are there performance issues when more than one client is connected to the server?

How to close TCP connection from server in Java

Here is use case I need to implement in Java:
Server is listening for push messages from some clients
If client has some data to push into server, it opens TCP connection and sends all messages
When client sends last message (special message saying that this is the last one) server should close connection by starting TCP closing handshake
I have problem with last step because I don't know how to close connection from server site. My current code is bellow. How to initiate connection closing TCP handshake form server site? Thank you for any help.
public class Server{
public static void main(String[] args) throws Exception {
while (true) {
int port = AppConfig.getInstance().getPort();
try (ServerSocket socket = new ServerSocket(port)) {
Socket server = socket.accept();
InetAddress ipAddress = server.getInetAddress();
MessageHandler handler = new MessageHandler(ipAddress);
InputStream in = server.getInputStream();
// reads all bytes from input stream and process them by given handler
processStream(in, handler);
in.close();
server.close();
} catch (Exception e) {
LoggingUtils.logException(e);
}
}
}
private static void processStream(InputStream in, MessageHandler handler) throws Exception {
// implementation is omitted
}
}

You've done it. in.close() closes the input stream, the socket output stream, and the socket.
What you should really close is whatever output stream was attached to the socket, to ensure it gets flushed, and you should probably do that in the processStream() method, with a saver server .close() in a finally block in the calling method.
NB Your socket names are really the wrong way round. It is customary to use ServerSocket serverSocket, and Socket socket = serverSocket.accept().

I may be not totally sure about this one, but I would believe that socket.close() will send all the commands (FIN/FIN-ACK)

Java serversocket not detecting lost connection

I have a socket client (on android phone) and server (on PC) both on a wifi network and the server successfully reads data from the client.
However, when I turn off the wifi on the phone the server read just hangs, whereas I was hoping some error would be thrown.
I do have setSoTimeout set on the server, but the read is not timing out.
On the PC netstat still shows an established connection
netstat -na | grep 6668
TCP 192.168.43.202:6668 192.168.43.26:43076 ESTABLISHED
Is there a way to tell if the client host has disappeared, or getting the read to time out?
Here is the server read
if (ss.isConnected()) {
try {
readData();
} catch (java.net.SocketTimeoutException ex) {
logger.warning(ex.toString());
} catch (InterruptedIOException ex) {
logger.warning(ex.toString());
} catch (IOException ex) {
logger.log(Level.WARNING, "Data communication lost will close streams - IOEx - socket status {0}", ss.socketStatus());
closeStreams();
} catch (Exception ex) {
logger.log(Level.WARNING, "Data communication lost will close streams - Ex - socket status {0}", ss.socketStatus());
closeStreams();
}
}
Where readData is,
public void readData() throws IOException {
for (int i = 0; i < data.length; i++) {
data[i] = ss.readDouble();
}
}
ss.readDouble() is,
public double readDouble() throws IOException {
return in.readDouble();
}
And the server connection,
public void connect() throws IOException {
if (serverSocket == null || serverSocket.isClosed()) {
init();
}
logger.log(Level.INFO, "Wait on " + serverSocket.getLocalPort());
server = serverSocket.accept();
serverSocket.close();
logger.log(Level.INFO, "Connected to {0}", server.getRemoteSocketAddress());
out = new DataOutputStream(server.getOutputStream());
in = new DataInputStream(server.getInputStream());
}

Make a timeout, so let's say no data has been sent for 10 minutes, close it in 60 seconds!
Setting a timeout for socket operations
The answer for this question may help you.

This is nature of TCP connection, not java sockets per se. If the remote peer disconects with broken connection, how should your server know that the peer simply has no data to send?
Writting on closed socket will cause exception, read will simply block if client doesnt end tcp connection properly, for the reason above.
If you go through socket API, you will find option to set timeout ( before proceeding with blocking operation).
You could also consider TCP KEEP Alive, which is also exposed by the Socket API.
// Edit: additional information as per the OP comment
When your client connects to server, you create a client socket to communicate with the peer. Your server socket is the one at which you are listening for new client connections. It is the client socket at which you specify keep alive or read timeout because this is the socket from which you read/write.
// your server is actually reference to ClientSocket
server = serverSocket.accept();
// keep alive duh
server.setKeepAlive(true);
serverSocket.close();

Java DatagramSocket sending to two different clients

i try to send a message over Java DatagramSocket to two different clients.
This is my send function:
public void sendData(String msg, UserData data) {
byte[] bA;
bA = msg.getBytes();
DatagramPacket pck;
try {
pck = new DatagramPacket(bA, bA.length, InetAddress.getByName(data.getConnectionInfo().getString("privateAddress")), data.getConnectionInfo().getInt("privatePort"));
ds.send(pck);
} catch (Exception e) {
e.printStackTrace();
}
}
So i call this function two times in a row with different host and port.
But just one client gets the message. When i insert a Thread.sleep(1000) between the two calls of this function everything works fine. So why is it not possible to send two messages to two client in a row without waiting?
Thanks for your help.
Edit:
Sorry,
ds is the DatagramSocket. It is global and created at the beginning.
The addresses and ports are correct, otherwise it would also not work with the Thread.sleep inside.
DatagramSocket ds = new DatagramSocket(6312);

Socket does not receive messages

I have written a simple client and simple udp server that needs to read string messages from particular port. here is the UDP-socket:
public class UDPServer {
// boolean variable defines if the infinite loop
// in startServer() runs or not
private boolean isSwitched = false;
private DatagramSocket socket = null;
public UDPServer(int port) throws SocketException {
socket = new DatagramSocket(port);
Logger.getLogger(Main.class.getName()).log(Level.INFO, "Server started! Bound to port: " + port);
}
//this method start the server and switches on the infinite loop to
// listen to the incoming UDP-packets
public void startServer() throws IOException {
this.isSwitched = true;
Logger.getLogger(Main.class.getName()).log(Level.INFO, "Server starts listening!");
while (isSwitched) {
byte[] size = new byte[30];
DatagramPacket dp = new DatagramPacket(size, size.length);
try {
System.out.println("Debug: receive loop started!");
socket.receive(dp);
System.out.println("Debug: Packet received after socket.receive!");
Thread requestDispatch = new Thread(new Request(dp.getData()));
requestDispatch.start();
} catch (SocketException ex) {
Logger.getLogger(Main.class.getName()).log(Level.INFO, "Stops listening on specified port!");
}
}
}
// this method stops the server from running
public void stopServer() {
this.isSwitched = false;
socket.close();
Logger.getLogger(Main.class.getName()).log(Level.INFO, "Server is shut down after last threads complete!");
}
}
I deploy it on the remote server and switch on the program. The server prints out that it started listening so it reaches the socket.receive() stage. Then I send a UDP-message from a remote client. But nothing happens. The udp-server does not move any further - it justs holds and seems to receive no messages.
I tried to debug the ports with the tcpdump and it shows that messages come to the required port. but java program does not seem to receive them.
When I issue this command on the remote server:
tcpdump udp port 50000
and send a few packets thats what it writes:
12:53:40.823418 IP x.mobile.metro.com.42292 > y.mobile.metro.com.50000: UDP, length 28
12:53:43.362515 IP x.mobile.metro.com.48162 > y.mobile.metro.com.50000: UDP, length 28

I tested your server code locally with netcat and it works just fine, so the problem has to be somewhere else. Are you sure you're actually sending UDP packets? Did you run tcpdump on the remote server? When not, maybe your packets get filtered.

Ok, question resolved. The problem was:
FIREWALL on Red Hat linux, which I successfully switched off for the required port.