Java关闭挂钩中的死锁

Question

System.exit() will exit JVM abruptly and graceful shutdown will not happen. But System.exit() has hooks for graceful shutdown. But its get deadlock..

class ExitPuzzle{
    private static final Object lock = new Object();

    public static void main(String... args) {
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Locking");
                synchronized (lock) {
                    System.out.println("Locked");
                }
            }
        }));
        synchronized (lock) {
            System.out.println("Exiting");
            System.exit(0);
        }
    }
}

Output is ::

       Exiting
       Locking

Question is Why JVM is not get shutdown when System.exit(0); gets executed ? Why its getting deadlock ? Is the developer need to take care while using ShutDowmHook in code or should it to not allow to write deadlock code ?

Answer 1

The program above deadlocks because two threads are asking for the same lock, and the one that holds the lock never lets go. Within the simple example above, the lock is not required at all.

At first it may not be clear that there are multiple threads here, so to confirm this here is the snippet from the documentation of Runtime.addShutdownHook

A shutdown hook is simply an initialized but unstarted thread. When the virtual machine begins its shutdown sequence it will start all registered shutdown hooks in some unspecified order and let them run concurrently.

The other aspect that may not be clear is that the call to System.exit(0) will not exit due to the dead lock. This is because System.exit(0) blocks until the shutdown threads have all completed. This can be confirmed by reading the code below, taken from ApplicationShutdownHooks.runHooks, and is invoked a little way into System.exit(0). I have highlighted with comments the two key lines. 1) the starting of the new threads, and 2) blocking until they complete. And as mentioned above, this join() will not return because the lock that is required by the registered shutdown hook will not be released until AFTER join() has returned. This circular situation is the definition of a deadlock, A cannot continue until B is finished and B cannot continue until A finishes; thus no progress can be made.

static void runHooks() {
    Collection<Thread> threads;
    synchronized(ApplicationShutdownHooks.class) {
        threads = hooks.keySet();
        hooks = null;
    }

    for (Thread hook : threads) {
        hook.start();                    // STARTS THE EXTRA THREADS
    }
    for (Thread hook : threads) {
        try {
            hook.join();                 // WAITS FOR THE EXTRA THREADS TO FINISH
        } catch (InterruptedException x) { }
    }
}

Answer 2

The javadoc on Runtime.addShutdownHook has quite a bit of detail about this:

Shutdown hooks run at a delicate time in the life cycle of a virtual machine and should therefore be coded defensively. They should, in particular, be written to be thread-safe and to avoid deadlocks insofar as possible. They should also not rely blindly upon services that may have registered their own shutdown hooks and therefore may themselves in the process of shutting down. Attempts to use other thread-based services such as the AWT event-dispatch thread, for example, may lead to deadlocks.

Answer 3

Runtime.getRuntime().halt(0) 

戕延迟计时器是用于避免死锁按照另一替代此文章。