Graceful Shutdown in Dubbo: From OS Signals to JVM and Spring Integration

During a recent interview the author was asked how Dubbo ensures that a request is not abruptly terminated when an application restarts, prompting a detailed explanation of graceful shutdown across multiple layers.

Graceful shutdown means avoiding situations such as unclosed monitors, unnotified callers, abruptly killed threads, or services becoming available before they are ready; instead, the system should mark the service as unavailable, finish in‑flight requests, and then stop.

At the operating‑system level, using kill -9 (SIGKILL) terminates a process instantly, while kill -15 (SIGTERM) sends a termination signal that the application can handle to perform cleanup before exiting.

Containers provide similar support: docker stop sends SIGTERM to the container’s main process and, after a configurable timeout, SIGKILL; docker kill sends SIGKILL directly.

On the JVM side, graceful shutdown is achieved with a shutdown hook. Example:

package com.hollis;

public class ShutdownHookTest {
    public static void main(String[] args) {
        boolean flag = true;
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("hook execute...");
        }));
        while (flag) {
            // app is running
        }
        System.out.println("main thread execute end...");
    }
}

When the process receives SIGTERM, the hook runs before the JVM exits, as shown by the console output.

Spring builds on the JVM hook by registering its own shutdown hook and exposing events such as ContextClosedEvent. Developers can implement ApplicationListener<ContextClosedEvent> to perform custom cleanup:

@Component
public class MyListener implements ApplicationListener<ContextClosedEvent> {
    @Override
    public void onApplicationEvent(ContextClosedEvent event) {
        // cleanup before container shutdown
    }
}

Dubbo adopts the same mechanism. Its SpringExtensionFactory registers the Spring application context and ensures the Dubbo shutdown hook is invoked:

public class SpringExtensionFactory implements ExtensionFactory {
    public static void addApplicationContext(ApplicationContext context) {
        CONTEXTS.add(context);
        if (context instanceof ConfigurableApplicationContext) {
            ((ConfigurableApplicationContext) context).registerShutdownHook();
            DubboShutdownHook.getDubboShutdownHook().unregister();
        }
        BeanFactoryUtils.addApplicationListener(context, SHUTDOWN_HOOK_LISTENER);
    }
}

In summary, graceful shutdown for Dubbo involves coordinated support from the operating system, Docker, the JVM, Spring, and Dubbo itself, illustrating how multiple infrastructure layers must work together to achieve a clean service termination.