The following program can handle almost 65000 (65K) request with a single instance.
/**
* This server socket program has been created to test the programe with -client and -server JVM parameters.
*/
package sockets;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @author prabhu kvn
*
*/
public class ServerSocketDemoWithBlockingQueue {
Logger logger = LoggerFactory.getLogger(this.getClass().getName());
/**
* A blocking queue to handle connections. this can hold up to one lakh sockets
*/
/**
* Default values
*/
private int queueLength = 10000;
int serverThreadCount = 1;
BlockingQueue<Socket> queue = new LinkedBlockingQueue<>(queueLength);
/**
* Default Constructor
*/
public ServerSocketDemoWithBlockingQueue() {
}
/**
* Default Constructor
*/
public ServerSocketDemoWithBlockingQueue(int serverThreadCount, int queueLength) {
this.serverThreadCount = serverThreadCount;
this.queueLength = queueLength;
this.queue = new LinkedBlockingQueue<>(queueLength);
}
/**
* Entry point for server start up
*
* @param args
*/
public static void main(String[] args) {
ServerSocketDemoWithBlockingQueue demo = new ServerSocketDemoWithBlockingQueue();
demo.startServer();
}
/**
* Starting the server to handle asynch connections
*/
private void startServer() {
logger.info("Starting the server with {} threads and queue size {}", serverThreadCount, queueLength);
ExecutorService service = Executors.newFixedThreadPool(serverThreadCount);
for (int i = 0; i < serverThreadCount; i++) {
service.submit(new ServerProcessing(queue));
}
ServerSocket serverSocket = null;
try {
// create the server socket
serverSocket = new ServerSocket(8181, 100000);
while (true) {
Socket socket = serverSocket.accept();
try {
queue.put(socket);
} catch (InterruptedException e) {
logger.error("Problem in accepting new connections : {}", e);
e.printStackTrace();
}
}
} catch (IOException e) {
logger.error("Problem in creating server socket {}", e);
e.printStackTrace();
} finally {
if (null != serverSocket) {
try {
serverSocket.close();
logger.info("Server Socket closed Successfully.");
} catch (IOException e) {
logger.error("Problem in closing server socket.");
e.printStackTrace();
}
}
}
}
}
/**
* Processing class
*
* @author prabhukvn
*
*/
class ServerProcessing extends Thread {
BlockingQueue<Socket> queue;
volatile int counter = 0;
public ServerProcessing(BlockingQueue<Socket> queue) {
this.queue = queue;
}
@Override
public void run() {
while (true) {
try {
process(queue.take());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* Execute the actual work.F
* @param socket
* @return
* @throws IOException
* @throws SocketException
* @throws InterruptedException
*/
private int process(Socket socket) throws IOException, SocketException, InterruptedException {
System.out.println("Server Socket:" + socket);
OutputStream out = socket.getOutputStream();
out.write(("Request received" + counter).getBytes());
counter++;
socket.setKeepAlive(true);
// Thread.sleep(1000);
// allow client to close the connection
socket.close();
return counter;
}
}
