java.net.BindException: Address already in use

[Suresh Khant]

Hi All,

As i have mentioned in the above post :

in the first deploy of the war file , it works fine but whenever i redeploy the war file


i will get the error : java.net.BindException: Address already in use

it seems that port will be still opened even so if I undeploy the war file


important points to mention :
1) this problem does not arise under windows
2)this problem appears under linux : after undeploy of the war file i used to check whether the port still in use or not using 2 following commands
a) it will be still listening if i use the command
#netstat -anp | grep 11900
tcp 0 0 0.0.0.0:11900 0.0.0.0:* LISTEN -

b) the port appears to be unused if i use the command
#lsof -i:11900


any one tell me how to fix the issue

here is the full code :

TCPServerServlet.java

package com.example.rox.nio;


import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;



public class TCPServerServlet extends HttpServlet {
    /**
     *
     */
    private static final long serialVersionUID = -830776846560631062L;
    TCPServer tcpServer;

  
    /**
     * Constructor of the object.
     */
    public TCPServerServlet() {
        super();
    }

    /**
     * Destruction of the servlet. <br>
     */
    @Override
    public void destroy() {
    	        

        Log.getLogger().info("TCPServerServlet...destroy...Shutting down TCP server ... ");
        Log.getLogger().info("TCPServerServlet...destroy...Trying to call TCPServer.setStop()");
        TCPServer.setStop(true);
        Log.getLogger().debug("TCPServerServlet...destroy...I am going to interrupt All Threads");
        interruptAllThreads();
        Log.getLogger().debug("TCPServerServlet...destroy...I am going to close TCP Server Channel");
        closeTCPServerServerChannel();
        Log.getLogger().debug("TCPServerServlet...destroy...I am going to destroy everything");
        //this.uDPSocketServer = null;
        super.destroy();
    }

    private void closeTCPServerServerChannel() {
    	try {
    		if (TCPServer.serverChannel.isOpen()){
    			TCPServer.serverChannel.close();
    			Log.getLogger().debug("The TCP Server Channel successfully closed");
    		}
		} catch (IOException e) {
			Log.getLogger().info("TCPServerServlet...closeTCPServerServerChannel...Error in closing TCPServer server channel");
		}
		
	}

	/**
     * The doGet method of the servlet. <br>
     *
     * This method is called when a form has its tag value method equals to get.
     *
     * @param request the request send by the client to the server
     * @param response the response send by the server to the client
     * @throws ServletException if an error occurred
     * @throws IOException if an error occurred
     */
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        Log.getLogger().info(" Reciivng a request");
  }

   @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        this.tcpServer= new TCPServer(11900);
    }
   
   public void interruptAllThreads(){
		
		Log.getLogger().info("interrupt All Threads... marking the starting ");
		if (TCPServer.stop){
			Log.getLogger().debug("interruptAllThreads...TCPServer.stop has a true value ");
			if (TCPServer.serverChannel!=null){
					TCPServer.nioServer.interrupt();
					TCPServer.worker.interrupt();
					this.tcpServer.interrupt();
			    	try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						Log.getLogger().info("interruptAllThreads...Error Sleeping for 1000-3.Reason:"+e.getMessage());
					}
					Log.getLogger().info("interruptAllThreads...Stopping All the applications");
			}else{
				Log.getLogger().debug("interruptAllThreads...TCPServer channel is null");
			}
		}else{
			Log.getLogger().info("interruptAllThreads...I am sorry i can not do anything because the TCPServer.stop is not matched");
		}
		Log.getLogger().info("interruptAllThreads...marking the end ");
	}

}

TCPServer.java

package com.example.rox.nio;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.util.Date;



public class TCPServer extends Thread {
	
	//private ServerSocketChannel serverSocketChannel;
	public static ServerSocketChannel serverChannel;
	private InetAddress hostAddress;
	public static boolean stop = false;
	public static EchoWorker worker = new EchoWorker();
	public static NioServer nioServer ;
	
	//private Selector selector ;
	
    
	
	
	public static synchronized boolean isStop() {
		return stop;
	}

	public static synchronized void setStop(boolean stop) {
		Log.getLogger().info("The stop value will be changed to :"+stop);
		TCPServer.stop = stop;
	}

	public TCPServer(int port) {
		
      	Log.getLogger().debug("TCP server running on port : "+port+" , date:"+new Date() );
		try {
			nioServer =   new NioServer(initSelector(), worker);
			new Thread(worker).start();
			new Thread(nioServer).start();
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
	
	public void run(){
}
	
	

	private Selector initSelector() throws IOException {
		try{
		
			if ((!stop)){
				Log.getLogger().debug("Step 1");
				// Create a new selector
				Selector socketSelector = SelectorProvider.provider().openSelector();
				Log.getLogger().debug("Step 2");
				// Create a new non-blocking server socket channel
				this.serverChannel = ServerSocketChannel.open();
				Log.getLogger().debug("Step 3");
				this.serverChannel.configureBlocking(false);
				Log.getLogger().debug("Step 4");
				// Bind the server socket to the specified address and port
				InetSocketAddress isa = new InetSocketAddress(this.hostAddress, 11900);
				Log.getLogger().debug("Step 5");
				
				this.serverChannel.socket().setReuseAddress(true);
				
				if (!(this.serverChannel.socket().isBound())){
					Log.getLogger().info("the serverSocketChannel has not been already bound , so we are bind it manually");
					this.serverChannel.socket().bind(isa);
				}else{
					Log.getLogger().info("the serverSocketChannel has been already bound ,NO bind will be assigned");
				}
					
				Log.getLogger().debug("Step 6");
				// Register the server socket channel, indicating an interest in 
				// accepting new connections
				this.serverChannel.register(socketSelector, SelectionKey.OP_ACCEPT);
				Log.getLogger().debug("Step 7");
				return socketSelector;
			}
		}catch(Exception e){
			Log.getLogger().error("Some problem has been arised.Reason:"+e.getMessage());
			//this.serverChannel.close();
			//initSelector();
		}
			return null;
		
	}
	
}

ServerDataEvent.java

package com.example.rox.nio;

import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;


class ServerDataEvent {
	public NioServer server;
	public SocketChannel socket;
	public byte[] data;
	public SelectionKey key;
	
	public ServerDataEvent(NioServer server, SocketChannel socket, byte[] data,SelectionKey key) {
		System.out.println("ServerDataEvent");
		this.server = server;
		this.socket = socket;
		this.data = data;
		this.key = key;
		Log.getLogger().debug("Printing data in bytes");
		for (byte b : data) {
			//System.out.print(b);
		}
		Log.getLogger().debug("");
	}
}

RspHandler.java

package com.example.rox.nio;
public class RspHandler {
	private byte[] rsp = null;
	
	public synchronized boolean handleResponse(byte[] rsp) {
		this.rsp = rsp;
		this.notify();
		return true;
	}
	
	public synchronized void waitForResponse() {
		while(this.rsp == null) {
			try {
				this.wait();
			} catch (InterruptedException e) {
			}
		}
		
		System.out.println(new String(this.rsp));
	}
}

NioServer.java

package com.example.rox.nio;
import java.io.IOException;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class NioServer implements Runnable {
	// The host:port combination to listen on
/*	private InetAddress hostAddress;
	private int port;*/

	// The channel on which we'll accept connections
	//private ServerSocketChannel serverChannel;

	// The selector we'll be monitoring
	private Selector selector;

	// The buffer into which we'll read data when it's available
	private ByteBuffer readBuffer = ByteBuffer.allocate(8192);

	private EchoWorker worker;

	// A list of PendingChange instances
	private List pendingChanges = new LinkedList();

	// Maps a SocketChannel to a list of ByteBuffer instances
	private Map pendingData = new HashMap();

	public NioServer(Selector currentSelector, EchoWorker worker) throws IOException {
		/*this.hostAddress = hostAddress;
		this.port = port;*/
		this.selector = currentSelector;
		this.worker = worker;
	}

	public void send(SocketChannel socket, byte[] data) {
		//System.out.println("send");
		synchronized (this.pendingChanges) {
			// Indicate we want the interest ops set changed
			this.pendingChanges.add(new ChangeRequest(socket, ChangeRequest.CHANGEOPS, SelectionKey.OP_WRITE));

			// And queue the data we want written
			synchronized (this.pendingData) {
				List queue = (List) this.pendingData.get(socket);
				if (queue == null) {
					queue = new ArrayList();
					this.pendingData.put(socket, queue);
				}
				queue.add(ByteBuffer.wrap(data));
			}
		}

		// Finally, wake up our selecting thread so it can make the required changes
		this.selector.wakeup();
	}

	public void run() {
		try{
			while (!(TCPServer.stop)) {
			//while (true) {
				try {
					// Process any pending changes
					synchronized (this.pendingChanges) {
						Iterator changes = this.pendingChanges.iterator();
						while (changes.hasNext()) {
							ChangeRequest change = (ChangeRequest) changes.next();
							switch (change.type) {
							case ChangeRequest.CHANGEOPS:
								SelectionKey key = change.socket.keyFor(this.selector);
								key.interestOps(change.ops);
							}
						}
						this.pendingChanges.clear();
					}
	
					// Wait for an event one of the registered channels
					System.out.println("Wating for any client : "+ new Date());
					this.selector.select();
	
					// Iterate over the set of keys for which events are available
					Iterator selectedKeys = this.selector.selectedKeys().iterator();
					while (selectedKeys.hasNext() & (!(TCPServer.stop))) {
						System.out.println("Found some key");
						SelectionKey key = (SelectionKey) selectedKeys.next();
						selectedKeys.remove();
	
						if (!key.isValid()) {
							continue;
						}
	
						// Check what event is available and deal with it
						if (key.isAcceptable()) {
							System.out.println("Accept key");
							this.accept(key);
						} else if (key.isReadable()) {
							this.read(key);
						} else if (key.isWritable()) {
							this.write(key);
						}
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		
		}catch(Exception e){
			Log.getLogger().debug("Interrupt exists and thread NioServer will be stopped");
		}finally{
			
			return;
		}
	}

	private void accept(SelectionKey key) throws IOException {
		// For an accept to be pending the channel must be a server socket channel.
		ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();

		// Accept the connection and make it non-blocking
		SocketChannel socketChannel = serverSocketChannel.accept();
		Socket socket = socketChannel.socket();
		socketChannel.configureBlocking(false);

		// Register the new SocketChannel with our Selector, indicating
		// we'd like to be notified when there's data waiting to be read
		socketChannel.register(this.selector, SelectionKey.OP_READ);
	}

	private void read(SelectionKey key) throws IOException {
		SocketChannel socketChannel = (SocketChannel) key.channel();

		// Clear out our read buffer so it's ready for new data
		this.readBuffer.clear();

		// Attempt to read off the channel
		int numRead;
		try {
			numRead = socketChannel.read(this.readBuffer);
		} catch (IOException e) {
			// The remote forcibly closed the connection, cancel
			// the selection key and close the channel.
			key.cancel();
			socketChannel.close();
			return;
		}

		if (numRead == -1) {
			// Remote entity shut the socket down cleanly. Do the
			// same from our end and cancel the channel.
			key.channel().close();
			key.cancel();
			return;
		}

		// Hand the data off to our worker thread
		this.worker.processData(this, socketChannel, this.readBuffer.array(), numRead,key);
		
	}

	private void write(SelectionKey key) throws IOException {
		SocketChannel socketChannel = (SocketChannel) key.channel();

		synchronized (this.pendingData) {
			List queue = (List) this.pendingData.get(socketChannel);

			// Write until there's not more data ...
			while (!queue.isEmpty()) {
				ByteBuffer buf = (ByteBuffer) queue.get(0);
				socketChannel.write(buf);
				if (buf.remaining() > 0) {
					// ... or the socket's buffer fills up
					break;
				}
				queue.remove(0);
			}

			if (queue.isEmpty()) {
				// We wrote away all data, so we're no longer interested
				// in writing on this socket. Switch back to waiting for
				// data.
				key.interestOps(SelectionKey.OP_READ);
			}
		}
	}
	
	public void interrupt(){
		Log.getLogger().info("Trying to interrupt NIOServer Thread");
		Thread.currentThread().interrupt();
		Log.getLogger().info("Successful interrupt to  NIOServer Thread");
	}

}

EchoWorker.java

package com.example.rox.nio;

import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.util.LinkedList;
import java.util.List;

public class EchoWorker implements Runnable {
	private List queue = new LinkedList();
	
	public void processData(NioServer server, SocketChannel socket, byte[] data, int count,SelectionKey key) {
		Log.getLogger().debug("Processing data");
		byte[] dataCopy = new byte[count];
		System.arraycopy(data, 0, dataCopy, 0, count);
		//here we have to check whether the data are valid or not 
		//System.out.println("Adding some data which is "+new String(data));
		synchronized(queue) {
			System.out.println("synchronized");
			queue.add(new ServerDataEvent(server, socket, dataCopy,key));
			queue.notify();
		}
	}
	
	public void run() {
		ServerDataEvent dataEvent;
		while(!(TCPServer.stop)) {
		//while(true) {
			// Wait for data to become available
			synchronized(queue) {
				while(queue.isEmpty()) {
					try {
						queue.wait();
					} catch (InterruptedException e) {
					}
				}
				dataEvent = (ServerDataEvent) queue.remove(0);
			}
			
			// Return to sender
			//dataEvent.server.send(dataEvent.socket, dataEvent.data);
			if (TCPServer.stop){
				Log.getLogger().info("The Stop flag is true");
				return;
			}
				
			Log.getLogger().info("End of the EchoWorker Thread.");
		}
	}
	
	public void interrupt(){
		Log.getLogger().info("Trying to interrupt EchoWorker Thread");
		Thread.currentThread().interrupt();
		Log.getLogger().info("Successful interrupt to  EchoWorker Thread");
	}
}

ChangeRequest.java

package com.example.rox.nio;

import java.nio.channels.SocketChannel;

public class ChangeRequest {
	public static final int REGISTER = 1;
	public static final int CHANGEOPS = 2;
	
	public SocketChannel socket;
	public int type;
	public int ops;
	
	public ChangeRequest(SocketChannel socket, int type, int ops) {
		this.socket = socket;
		this.type = type;
		this.ops = ops;
	}
}

[Suresh Khant]

Hi All ,
I was trying to post reply to my old post : https://coderanch.com/t/485410/sockets/java/server-not-accept-all-clients
but accidently new post created (This is just to inform you that i did not intend to post something duplicates)


Thanking all for understanding , I am stuck in this issue ...........

[Nitesh Kant]

There is too much of code here to read.

In order to find out why your server did not shutdown, you would probably have to do a remote debug and find out whether the shutdown call reached the server.
If you feel the threads did not get interrupted, take a jstack of the process and see where the threads are stuck.

I would recommend using a library such as netty if you are trying to write an NIO server, instead of re-inventing the wheel.