ServletContextListener & Threads

[Dave Brown]

** To mods.. wasnt sure which forum to base this post.. Servlets/Threads etc please move it at your discretion.. **

Hi All,

Having a brain strain. Heres what i'm trying to achieve, I wish to have a Class which listens to a socket and launches new socket threads for each connection... (this is ok) But I want the listening class (SocketListener) to also implement the ServletContextListener so it launches and starts when my web app starts.. I'm having trouble getting this to launch in its own thread so it doesnt halt the progress of my J2EE server... as is whats happening at the moment..

Can anyone help me get my head around this servlet/threading problem.

Thankyou (Below is code for SocketListener class)

  
/*
 * SocketListener.java
 *
 * Created on 06 July 2006, 15:12
 *
 */
 
package net.dbws.tracker.Utils;
 
/* Imports here */
 
/**
 *
 * @author <a href="mailto  :mrgreen:  [e-mail]">Dave Brown</a>
 */
public class SocketListener implements ServletContextListener  {
    private static SocketListener ref = null;
    private ServerSocket listener = null;
    private boolean listening;
    private ArrayList activeConnections = new ArrayList();
    private String status;
    
    /** Creates a new instance of SocketListener */
    public SocketListener() {
    }
    
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        ServletContext sc = servletContextEvent.getServletContext();
        sc.setAttribute("socketListener",this);
 
        // TODO Need initlistener to run in its own thread...
        initListener();
    }
    
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        listening = false;
        if (listener != null && ! listener.isClosed()) {
            try {
                listener.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        listener = null;
    }
    
    public void start() {
        initListener();
    }
    public void stop() {
      if (listener != null && ! listener.isClosed())
      {
        try {
            listener.close();
            listening = false;           
        } catch (IOException ex) {
            System.out.println("[SocketListener] Could not stop listener "+ex.getMessage());
            ex.printStackTrace();
        }
      } else
           listening = false;
     
    }
    private void initListener() {
        if (listener != null && ! listener.isClosed()) {
            System.out.println("[SocketListener] Listener is already open... closing..");
            try {
                listener.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        try {
            System.out.println("[SocketListener] Initialising Socket Listener");
            listener = new ServerSocket(30000);
            System.out.println("Listening");
            listening = true;
            Socket sclient = null;
            while (true){
                try{
                    sclient = listener.accept();
                    ServerThread st = new ServerThread(sclient,activeConnections);
                                   
                    st.start();
                } catch(IOException e1) {
                    try {
                        sclient.close();
                    } catch (IOException e2) {}
                }
            }
        } catch (IOException ex) {
            System.out.println("[SocketListener] Error Initialising Socket Listener "+ex.getMessage());
            ex.printStackTrace();
            listening = false;
        }
        
    }
    public boolean isListening() {
        return listening;
    }
        
    public String getStatus() {
        StringBuilder sb = new StringBuilder();
        SimpleDateFormat sdf = new SimpleDateFormat();
        
        sb.append("Status @ "+sdf.format(new Date()) + "\n");
        sb.append("Listening : "+isListening());
        if (isListening()) {
            sb.append("");
        }
        return sb.toString();
    }
        
}
 

[ July 10, 2006: Message edited by: Bear Bibeault ]

[Travis Hein]

It looks like the issue is the contextInitialized is invoking the initListener(),

// TODO Need initlistener to run in its own thread...
initListener();
}

which then loops indefinately, as required, but does not return. the contextInitialized() is expecting to return as to let the rest of the application initialize.

I guess what you could do here is make your class also implement the runnable interface. and then have a member Thread myThread instance variable. the listener would then do something like a

myThread = new Thread(this)

to have the listening thread start and you would move the initListener call to the run() method so it gets called from the threaded invocationl.

Then have the contextDestroyed() clean up the running thread, if it is running. do something like:

if (myThread != null) {
  myThread.interrupt();
}
myThread = null;

This would allow the listener to later stop the thread when the app is reloaded; In a past project I found this to be an issue over time, in that zombie threads would sometimes stay around from previous app reloads.

Though this approach is sort of confusing in that we make a thread out of the context listener, that contains a nested thread instance of itself.


As a second idea, I have evolved make my own threaded service concept that manages the start and stop of the thread. Having the threaded part as a separate facility from initial context listeners enables me to restart the thread at any time within the lifespan of the application, or even be used outside of servlet containers, if that was ever a need for you as
well.

Here is my threaded service interface:

/**
 * An interface to provide a consistent means of controll threaded execution
 * within the application. This is intended to be used with services that
 * require daemon like behaviour.
 */
public interface ThreadedService extends ThreadedServiceInfo {
    /**
    * Starts the thread. This resets the counter for execution count and the uptime date stamp.
    */
    public void startThread();
 

    /**
    * Stops the thread. This resets the down time date stamp.
    */
    public void stopThread();
    
    /**
    * The thing that is to be executed within this thread. This is the body of the the threaded service, and is required to be implemented by the child class.
    */
    public void service();
    
    /**
     * Queries if this thread is currently running.
     *
     * @return The boolean state of the thread.
     */
    boolean getRunning ();
}

And a stub implementation class

/**
* A skeleton implementation of the ThreadedBean
*/
public abstract class ThreadedServiceImpl implements ThreadedService, Runnable {
    private static final Log log = LogFactory.getLog(ThreadedServiceImpl.class);
    
    /**
     * The default time, in milliseconds that should elapse before the run() method will re-invoke the service() method. This is currently set to 300 miliseconds.
     */
    public static long DEFAULT_SLEEP_INTERVAL = 300;
    private Thread runThread    = null;
    private boolean running     = false;
 
    public ThreadedServiceImpl() {
 
    }
 
    /* See ThreadedServiceInfo */
    public boolean getRunning() { return running; }
    
    protected void setRunning (boolean b) {
        this.running = b;
    }
 

    /* See ThreadedService */
    public void startThread() {
        if (runThread != null) {
            throw new IllegalArgumentException("thread already started.");
        }
 
        runThread = new Thread(this);
        setRunning(true);
    }
 
    /* See ThreadedService */
    public void stopThread() {
        setRunning(false);
 
        if (runThread != null) {
            runThread.interrupt();
        }
 
        runThread     = null;
    }
 

    /**
     * Ensures the thread is stopped when this object is destroyed
     */
    public void finalize () throws Throwable {
        if (getRunning()) {
            stopThread();
        }
        super.finalize();
    }
 

    /**
     * The method that will exeute the service. This is used by the Runnable interface, when this instance of class is ran within a thread.
     * It monitors the state of the running flag and invokes the service() method. Then tries to sleep for the configured value of sleepInterval property.
     * When the running flag is found to be off, the method exits.
    */
    public void run() {
 
        log.debug("Thread starting: (" + getName() + ")");
        while (running) {
            service();
            // a small sleep between invoking the next service is good if the service() body is empty.
            if (running) {
                try {
                    Thread.sleep(sleepInterval);
                }
                catch (InterruptedException ex) {
                // empty
                }
            } // if running
        } // while running
        log.debug("Thread exiting);
    }
 
    /* See ThreadedService */
    public abstract void service();
}

So you could make a child class of the ThreadedServiceImpl, and only need to specify the service() method and then put the contents of the while(true) in your thread loop into here. Then your listener could cleanly create the instance of your threaded service child class, (optionally stuffing it into a servlet context attribute), and then the contextInitialized() and contextDestroyed() would invoke the startThread() and stopThread() respectively. Your child class can override these as well if there is special initializition or cleanup, such as the network socket in your case.

[Dave Brown]

Thanks Travis, that helps me 100%.




Dave