I was running a few tests with sockets, and I encountered some strange behavior: A ServerSocket will refuse connections after the 50th client Socket connects to it, even if that client socket is closed before the next one is opened, and even if a delay is added between connections.
The following program is my experimental code, which in its current state, throws no exceptions and terminates normally. However, if the array size of Socket[] clients
is increased beyond 50, any client sockets attempting to connect after the 50th connection are refused by the server socket.
Question: Why is 50 the count at which socket connections are refused by a server socket?
public static void main(String[] args) {
try (ServerSocket server = new ServerSocket(2123)) {
Socket[] clients = new Socket[50];
for (int i = 0; i < clients.length; i++) {
clients[i] = new Socket("localhost", 2123);
System.out.printf("Client %2d: " + clients[i] + "%n", i);
clients[i].close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
I have run tests where another 50 sockets connect to another local server, and no issue occurred with 100 sockets being opened and closed, so I've deduced that its the server socket is refusing connections, and not some limit of opening client sockets, but I have been unable to discover why the server socket is limited to 50 connections, even though they are not connected simultaneously.
It's all in the JavaDoc:
The maximum queue length for incoming connection indications (a request to connect) is set to 50. If a connection indication arrives when the queue is full, the connection is refused.
Apparently your ServerSocket
never accepts any connections, just listens. You must either call accept()
and start handling the connection or increase the backlog queue size:
new ServerSocket(port, 100)
50 is the default value for backlog
http://docs.oracle.com/javase/1.4.2/docs/api/java/net/ServerSocket.html#ServerSocket%28int%29
The maximum queue length for incoming connection indications (a request to connect) is set to 50. If a connection indication arrives when the queue is full, the connection is refused.
Here's an example that works, in accordance with @TomaszNurkiewicz's answer:
import java.net.*;
import java.util.concurrent.atomic.AtomicBoolean;
public class SockTest{
public static void main(String[] args) {
final AtomicBoolean shouldRun = new AtomicBoolean(true);
try {
final ServerSocket server = new ServerSocket(2123);
Thread serverThread = new Thread(){
public void run() {
try {
while(shouldRun.get()) {
Socket s = server.accept();
s.close();
Thread.sleep(1);
}
} catch(Exception ex) {
ex.printStackTrace();
}
}
};
serverThread.start();
Socket[] clients = new Socket[150];
for (int i = 0; i < clients.length; i++) {
clients[i] = new Socket("localhost", 2123);
System.out.printf("Client %2d: " + clients[i] + "%n", i);
clients[i].close();
}
shouldRun.set(false);
} catch (Exception e) {
e.printStackTrace();
} finally {
shouldRun.set(false);
}
}
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With