Question

I am running a multi-threaded Java web application on Apache Tomcat 6. Instead of using the new Thread(); anti-pattern, I leave thread instantiation to Tomcat (see code below).

I noticed in the last days that the web application gets slower and slower. After restarting the servlet container everything is back to normal.

Since I am not terminating threads after processing them (Don’t know if I have to or if the Garbage Collector will destroy them), I am guessing that this is the cause for the performance loss.

The code basically looks like this:

Custom Server Listener (I added this to web.xml):

public class MyTaskRunner implements ServletContextListener {
  public static final ExecutorService EXECUTOR_SERVICE = ExecutorService.newFixedThreadPool(10000);

  public void contextDestroyed(ServletContextEvent sce) {
    EXECUTOR_SERVICE.shutdownNow();
  }
  public void contextInitialized(ServletContextEvent sce) {
  }
}

Thread instantiation:

for (Object foo : bar){
    MyTaskRunner.EXECUTOR_SERVICE.submit(new Runnable() {
      public void run() {
        doSomethingWith(foo);
    });
}

So, is there anything special that I have to do after run() has finished?

Answer 1

Some basic facts about threads and GC:

• While a thread is running, it will not be garbage collected.

• When a thread is terminated, its stack is deleted and its Thread object is removed from the ThreadGroup data structures. The remainder of the threads’ state is subject to the normal reachability rules.

• You don’t need to do anything special to make a thread terminate. It happens when the run method call ends, either because it returned, or because it exited with an (uncaught) exception.

---

Now to your particular problem. Many things could be causing your performance degradation. For instance:

• Some of your threads may be getting stuck; e.g. waiting on a lock, waiting for a notify that isn’t going to arrive, or just stuck in an infinite CPU loop.

• You may have too many threads running (doing useful, or semi-useful things), and the slowdown may be a result of lock contention, CPU resource starvation, or thrashing.

• You may have a memory leak of some kind, and the slowdown may be a symptom of your application starting to run out of heap space.

To figure out what is going on, you are going to need to do some performance monitoring:

• Look at the OS level stats to see if the application is thrashing.

• Use a memory profile to see if your application is short of memory. If it is, see if there is a memory leak, and track it down.

• Use a performance profiler to see if there are particular hotspots, or if there is a lot of lock contention.

---

I agree with the comment. A thread pool size of 10000 is dangerously large. It should be a small constant multiplied by the number of cores available to your application.