kill -l
HUP INT QUIT ILL TRAP ABRT EMT FPE KILL BUS SEGV SYS PIPE ALRM TERM URG STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ VTALRM PROF WINCH INFO USR1 USR2
复制代码

@SpringBootApplication
public class JunitSpringBootApplication {
  public static void main(String[] args) {
     SpringApplication.run(JunitSpringBootApplication.class, args);
     Runtime.getRuntime().addShutdownHook(new Thread(){
       @Override
       public void run() {
         System.out.println("执行 shutdown hook");       }
     });
  }
}
复制代码

@RestController
public class HiController implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("destroy bean.....");
    }
}
复制代码

执行 shutdown hook
destroy bean.....
复制代码

Runtime.getRuntime().addShutdownHook(new Thread(){
    @Override
    public void run() {
       System.out.println("执行 shutdown hook");          }
 });
复制代码

public void addShutdownHook(Thread hook) {
  SecurityManager sm = System.getSecurityManager();
  if (sm != null) {
    sm.checkPermission(new RuntimePermission("shutdownHooks"));
  }
  ApplicationShutdownHooks.add(hook);
}
复制代码

private static IdentityHashMap<Thread, Thread> hooks;
static {
  try {
    Shutdown.add(1 /* shutdown hook invocation order */,
                 false /* not registered if shutdown in progress */,
                 new Runnable() {
                   public void run() {
                     // 执行注册的 hooks
                     runHooks();
                   }
                 }
                );
    hooks = new IdentityHashMap<>();
  } catch (IllegalStateException e) {
    // application shutdown hooks cannot be added if
    // shutdown is in progress.
    hooks = null;
  }
}
// ================================
static synchronized void add(Thread hook) {
  if(hooks == null)
    throw new IllegalStateException("Shutdown in progress");
  if (hook.isAlive())
    throw new IllegalArgumentException("Hook already running");
  if (hooks.containsKey(hook))
    throw new IllegalArgumentException("Hook previously registered");
  hooks.put(hook, hook);
}
// 从 Map 中获取对应的线程、启动执行、并等待其返回
static void runHooks() {
  Collection<Thread> threads;
  synchronized(ApplicationShutdownHooks.class) {
    threads = hooks.keySet();
    hooks = null;
  }
  for (Thread hook : threads) {
    hook.start();
  }
  for (Thread hook : threads) {
    while (true) {
      try {
        hook.join();
        break;
      } catch (InterruptedException ignored) {
      }
    }
  }
}
复制代码

private static final int MAX_SYSTEM_HOOKS = 10;
private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];
static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
  synchronized (lock) {
    if (hooks[slot] != null)
      throw new InternalError("Shutdown hook at slot " + slot + " already registered");
    if (!registerShutdownInProgress) {
      if (state > RUNNING)
        throw new IllegalStateException("Shutdown in progress");
    } else {
      if (state > HOOKS || (state == HOOKS && slot <= currentRunningHook))
        throw new IllegalStateException("Shutdown in progress");
    }
    hooks[slot] = hook;
  }
}
复制代码

private static void runHooks() {
  for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
    try {
      Runnable hook;
      synchronized (lock) {
        // acquire the lock to make sure the hook registered during
        // shutdown is visible here.
        currentRunningHook = i;
        hook = hooks[i];
      }
      if (hook != null) hook.run();
    } catch(Throwable t) {
      if (t instanceof ThreadDeath) {
        ThreadDeath td = (ThreadDeath)t;
        throw td;
      }
    }
  }
}
复制代码

/* Invoked by Runtime.exit, which does all the security checks.
     * Also invoked by handlers for system-provided termination events,
     * which should pass a nonzero status code.
     */
static void exit(int status) {
  boolean runMoreFinalizers = false;
  synchronized (lock) {
    if (status != 0) runFinalizersOnExit = false;
    switch (state) {
      case RUNNING:       /* Initiate shutdown */
        state = HOOKS;
        break;
      case HOOKS:         /* Stall and halt */
        break;
      case FINALIZERS:
        if (status != 0) {
          /* Halt immediately on nonzero status */
          halt(status);
        } else {
          /* Compatibility with old behavior:
                     * Run more finalizers and then halt
                     */
          runMoreFinalizers = runFinalizersOnExit;
        }
        break;
    }
  }
  if (runMoreFinalizers) {
    runAllFinalizers();
    halt(status);
  }
  synchronized (Shutdown.class) {
    /* Synchronize on the class object, causing any other thread
             * that attempts to initiate shutdown to stall indefinitely
             */
    // 这个方法会调起 runHooks 方法
    sequence();
    halt(status);
  }
}
复制代码

protected void doClose() {
  // Check whether an actual close attempt is necessary...
  if (this.active.get() && this.closed.compareAndSet(false, true)) {
    LiveBeansView.unregisterApplicationContext(this);
      publishEvent(new ContextClosedEvent(this));
    // Stop all Lifecycle beans, to avoid delays during individual destruction.
    if (this.lifecycleProcessor != null) {
      try {
        this.lifecycleProcessor.onClose();
      }
      catch (Throwable ex) {
      }
    }
    // 销毁单例 bean、destroy 方法就是这里被触发
    destroyBeans();
    // 关闭上下文以及 beanfactory
    closeBeanFactory();
    // 空实现、让子类去扩展
    onClose();
    // Switch to inactive.
    this.active.set(false);
  }
}
复制代码

@FunctionalInterface
public interface TomcatConnectorCustomizer {
   /**
    * Customize the connector.
    * @param connector the connector to customize
    */
   void customize(Connector connector);
}
复制代码

@Component
public class GracefulShutdownTomcat implements TomcatConnectorCustomizer, ApplicationListener<ContextClosedEvent> {
    private final Logger log = LoggerFactory.getLogger(GracefulShutdownTomcat.class);
    private volatile Connector connector;
    private final int waitTime = 30;
    @Override
    public void customize(Connector connector) {
        this.connector = connector;
    }
    @Override
    public void onApplicationEvent(ContextClosedEvent contextClosedEvent) {
        this.connector.pause();
        Executor executor = this.connector.getProtocolHandler().getExecutor();
        if (executor instanceof ThreadPoolExecutor) {
            try {
                ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
                threadPoolExecutor.shutdown();
                if (!threadPoolExecutor.awaitTermination(waitTime, TimeUnit.SECONDS)) {
                    log.warn("Tomcat thread pool did not shut down gracefully within " + waitTime + " seconds. Proceeding with forceful shutdown");
                }
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
        }
    }
}
复制代码

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP);
        interruptWorkers();
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}
复制代码

private void interruptWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)
            w.interruptIfStarted();
    } finally {
        mainLock.unlock();
    }
}
复制代码

private List<Runnable> drainQueue() {
    BlockingQueue<Runnable> q = workQueue;
    ArrayList<Runnable> taskList = new ArrayList<Runnable>();
    q.drainTo(taskList);
    if (!q.isEmpty()) {
        for (Runnable r : q.toArray(new Runnable[0])) {
            if (q.remove(r))
                taskList.add(r);
        }
    }
    return taskList;
}
复制代码

try {
    while (task != null || (task = getTask()) != null) {
        w.lock();
        // If pool is stopping, ensure thread is interrupted;
        // if not, ensure thread is not interrupted.  This
        // requires a recheck in second case to deal with
        // shutdownNow race while clearing interrupt
        if ((runStateAtLeast(ctl.get(), STOP) ||
             (Thread.interrupted() &&
              runStateAtLeast(ctl.get(), STOP))) &&
            !wt.isInterrupted())
            wt.interrupt();
        try {
            beforeExecute(wt, task);
            Throwable thrown = null;
            try {
                task.run();
            } catch (RuntimeException x) {
                thrown = x; throw x;
            } catch (Error x) {
                thrown = x; throw x;
            } catch (Throwable x) {
                thrown = x; throw new Error(x);
            } finally {
                afterExecute(task, thrown);
            }
        } finally {
            task = null;
            w.completedTasks++;
            w.unlock();
        }
    }
    completedAbruptly = false;
} finally {
    processWorkerExit(w, completedAbruptly);
}
复制代码

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN);
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}
复制代码