分析多线程Java应用程序

Question

In an open source application I'm participating, we've got a bug, where the application doesn't always close properly. That's what I'd like to solve.

Experience has shown that this happens most of the time when threads and processes are being started, but not managed correctly (eg a thread is waiting on a socket connection, the application is being shut down and the thread keeps on waiting).
With this in mind I've searched for '.start()' in the entire source and found 53 occurrences (which scared me a bit).
As a first step, I wanted to create a helper class (ThreadExecutor) where the current code 'thread.start()' would be replaced by 'ThreadExecutor.Execute(thread)' to have a) only a few changes in the existing source and b) a single class where I can easily check which threads don't end as they should. To do this I wanted to

• add the thread to be executed to a list called activeThreads when calling the Execute method
• start the thread
• remove it from the activeThreads list when it ends.

This way I'd have an up to date list of all executing threads and when the app hangs on shutdown I could see in there which thread(s) is(are) causing it.

Questions:

• What do you think about the concept? I'm usually coding c# and know how I'd do it using .NET with workers, but am not too sure what's best in Java (I'd like to modify as few lines of code as possible in the existing source).
• If the concept seems ok, how can I get notified of a thread terminating. I'd like to avoid having an additional thread checking every once in a while what the state of all threads contained in activeThreads is, to remove them if they terminated.

Just to clarify: Before figuring out how to terminate the application properly, what I'm asking here is what's the best/easiest way to find which threads are at cause for certain test cases which are pretty hard to reproduce.

Answer 1

I would attempt to analyze your application's behavior before changing any code. Code changes can introduce new problems - not what you want to do if you're trying to solve problems.

The easiest way to introspect the state of your application with regard to which threads are currently running is to obtain a thread dump. You said that your problem is that the application hangs on shutdown. This is the perfect scenario to apply a thread dump. You'll be able to see which threads are blocked.

You can read more about thread dumps here .

Answer 2

Try to make all threads daemon(when all remaining threads are daemon the JVM terminates). Use thread.setDaemon(true) before starting each thread.

Answer 3

You could try to look into your application using jvisualvm (which is shipped with the jdk, find it in the bin folder of your jdk). JVisualVM can connect to your application and display a lot of interesting information, including which processes are still running. I'd give that a shot before starting down the road you describe.

Here is some documentation on JVisualVM should you need it.

Answer 4

The best way in java is to use Thread pools instead of Threads directly (although using threads directly is accepted). Thread pools accept Runnable objects, which you can see as Tasks. The idea is that most threads would do a small task and then end, because making a Thread is expensive and harder to manager you can use the threadpool, which allows things like 'ThreadPoolExecutor.awaitTermination()`. If you have more tasks than Threads in the pool, remaining tasks will just be queued.

Changing a Thread into a Runnable is easy, and you can even execute a runnable on a Thread you make yourself.

Note that this might not work for threads that run a long time, but your question seems to suggest that they will eventually finish.

As for your second question, the best way to find out which threads are running at a certain point is to run the application in a debugger (such as Eclipse) and pause all threads on a breakpoint in the close function.

Answer 5

I would try the trial edition of jprofiler or something similar, which gives you a lot of insight into what your application and its threads actually do.

Don't change the code yet, but try to reproduce and understand when this happens.

Answer 6

Create yourself a static thread pool.

static ExecutorService threads = Executors.newCachedThreadPool();

For every start of thread change:

new Thread(new AThread()).start();

to

threads.submit(new AThread ());

When your code exits, list all running threads with:

List<Runnable> runningThreads = threads.shutdownNow();
for ( Runnable t : runningThreads ) {
  System.out.println("Thread running at shutdown: "+t.toString());
}

This will not only shut down all running threads, it will list them out for you to see what their issue is.

EDIT : Added

If you want to keep track of all running threads use:

Future f = threads.submit(new AThread ());

and store it in a list somewhere. You can then find out about its state with calls like:

f.isDone();
... etc.