Can't get all AWT threads to close on exit

Question

I'm attempting to get my Java application to close, but threads are being left open.

When close is clicked using the default windows x button, everything shuts fine (probably due to EXIT_ON_CLOSE?)- but when I use a programmatic button, it hangs on thread.join().

Even worse, the window is disposed fine, so the user would think it's shut- yet there are several AWT threads that stay open. My main thread is waiting on a thread with an id of 20, but I have no idea how to get thread IDs.

Does anyone have any suggestions?

Here's my exit code:

public synchronized void stop() {
    running = false;
    frame.dispose();
    WindowEvent wev = new WindowEvent(frame, WindowEvent.WINDOW_CLOSING);
    Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(wev);
    try {
        if (server != null) {
            server.exit();
        }
        client.exit();
        thread.join();
        new Thread(){
            public void run() {
                System.exit(0);
            }
        }.start();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        e.printStackTrace();
        System.exit(1);
    }
}

and here are the threads open post-exit:

and here's the contents of my run() method:

public void run() {
    requestFocus();
    while (running) {
        getTimer().tick();
        if (System.currentTimeMillis() - getTimer().getSecond() > 1000) {
            // every second, add a second, print fps and mod title with fps
            getTimer().accumulateSecond();
            //System.out.println(getTimer().returnFPS());
            frame.setTitle(title + "  |  " + getTimer().returnFPS());
            getTimer().resetTick();
            ticker++;
        }
        while (getTimer().getDelta() >= 1) {
            // every time delta goes greater than one, update and supertick
            update();
            getTimer().superTick();
        }
        if (getTimer().getFPS() > 100) {
            try {
                Thread.sleep(5);
            } catch (Exception e) {
                System.err.println("Sleeping failed: " + e);
            }
        } 
        render();
        if (ticker > 30) {
            ticker = 0;
            getTimer().hourTick();
        }

    }
    stop();
}

Answer 1

Update:

After seeing more of your code, I'm pretty sure your problem is that you are calling stop() (which is synchronized) from one thread. Inside stop(), you call thread.join(), which attempts to wait for the thread instance to finish its run() method. Setting the running flag causes run() to exit its while loop, but the last line of code in the method is another call to stop(). If this is the same stop() method you showed us, then you have a deadlock.

The stop() call inside your run() method will never be able to enter the method, because the first thread is still inside stop() and is waiting for run() to complete (which it never will, because it's waiting to be able to call and enter stop()). Deadlock.

You will have to remove the call to stop() from within run(), or find another way to rework your code.

---

I wouldn't worry about identifying particular thread IDs. Worry about letting all your threads complete properly.

First of all, Thread#join() does not stop a thread. It waits for it to finish. Something else you're doing must cause/allow the thread instance to complete its run() method.

The only thing I see that could possibly do this is setting

    running = false;

Is your thread object checking that flag inside its run() method? For example:

public void run() {
    while (isRunning()) {

        // do some work
        Thread.sleep(delay);
    }
}

where isRunning() would return you the value of the running variable?

Now, I can't say without seeing more of your code. However, you may have chosen to implement isRunning() like this:

public synchronized boolean isRunning() {
    return running;
}

If you did that, then there's a problem. The main thread will acquire the lock in the stop() method you showed us. Then it will get to the thread.join() call, at which point it starts waiting for the worker thread. If the worker thread then calls isRunning() which is synchronized on the same lock, then isRunning() will block, because the lock is already held by virtue of the main thread being inside stop().

The same basic problem could occur if the thread object is trying to call any other synchronized method from the class whose code you showed us.

Long story short, we'd need to see some more code (what is running in the thread represented by the thread variable). But, you may have reached a deadlock here.

Read more here about stopping a thread gracefully