Tomcat 中的shutdowhook
今天去Tomcat代码里面查东西，无意中发现：1 /**
2 * Start a new server instance.
3 */
4 public void start() {
5
6 if (server == null) {
7 load();
8 }
9
10 long t1 = System.currentTimeMillis();
11
12 // Start the new server
13 if (server instanceof Lifecycle) {
14 try {
15 ((Lifecycle) server).start();
16 } catch (LifecycleException e) {
17 log.error("Catalina.start: ", e);
18 }
19 }
20
21 long t2 = System.currentTimeMillis();
22 log.info("Server startup in " + (t2 - t1) + " ms");
23
24 try {
25 // Register shutdown hook
26 if (useShutdownHook) {
27 if (shutdownHook == null) {
28 shutdownHook = new CatalinaShutdownHook();
29 }
30 Runtime.getRuntime().addShutdownHook(shutdownHook);
31 }
32 } catch (Throwable t) {
33 // This will fail on JDK 1.2. Ignoring, as Tomcat can run
34 // fine without the shutdown hook.
35 }
36
37 if (await) {
38 await();
39 stop();
40 }
41
42 }
其中：
1 /**
2 * Shutdown hook which will perform a clean shutdown of Catalina if needed.
3 */
4 protected class CatalinaShutdownHook extends Thread {
5
6 public void run() {
7
8 if (server != null) {
9 Catalina.this.stop();
10 }
11
12 }
13
14 }
而：
1 /**
2 * Registers a new virtual-machine shutdown hook.
3 *
4 *The Java virtual machine shuts down in response to two kinds
5 * of events:
6 *
7 *
8 *
9 * The program exits normally, when the last non-daemon
10 * thread exits or when the {@link #exit exit} (equivalently,
11 * {@link System#exit(int) System.exit}) method is invoked, or
12 *
13 * The virtual machine is terminated in response to a
14 * user interrupt, such as typing ^C, or a system-wide event,
15 * such as user logoff or system shutdown.
16 *
17 *
18 *
19 *A shutdown hook is simply an initialized but unstarted
20 * thread.When the virtual machine begins its shutdown sequence it will
21 * start all registered shutdown hooks in some unspecified order and let
22 * them run concurrently.When all the hooks have finished it will then
23 * run all uninvoked finalizers if finalization-on-exit has been enabled.
24 * Finally, the virtual machine will halt.Note that daemon threads will
25 * continue to run during the shutdown sequence, as will non-daemon threads
26 * if shutdown was initiated by invoking the {@link #exit exit}
27 * method.
28 *
29 *Once the shutdown sequence has begun it can be stopped only by
30 * invoking the {@link #halt halt} method, which forcibly
31 * terminates the virtual machine.
32 *
33 *Once the shutdown sequence has begun it is impossible to register a
34 * new shutdown hook or de-register a previously-registered hook.
35 * Attempting either of these operations will cause an
36 * {@link IllegalStateException} to be thrown.
37 *
38 *Shutdown hooks run at a delicate time in the life cycle of a virtual
39 * machine and should therefore be coded defensively.They should, in
40 * particular, be written to be thread-safe and to avoid deadlocks insofar
41 * as possible.They should also not rely blindly upon services that may
42 * have registered their own shutdown hooks and therefore may themselves in
43 * the process of shutting down.
44 *
45 *Shutdown hooks should also finish their work quickly.When a
46 * program invokes {@link #exit exit} the expectation is
47 * that the virtual machine will promptly shut down and exit.When the
48 * virtual machine is terminated due to user logoff or system shutdown the
49 * underlying operating system may only allow a fixed amount of time in
50 * which to shut down and exit.It is therefore inadvisable to attempt any
51 * user interaction or to perform a long-running computation in a shutdown
52 * hook.
53 *
54 *Uncaught exceptions are handled in shutdown hooks just as in any
55 * other thread, by invoking the {@link ThreadGroup#uncaughtException
56 * uncaughtException} method of the thread's {@link
57 * ThreadGroup} object.The default implementation of this method
58 * prints the exception's stack trace to {@link System#err} and
59 * terminates the thread; it does not cause the virtual machine to exit or
60 * halt.
61 *
62 *In rare circumstances the virtual machine may abort, that is,
63 * stop running without shutting down cleanly.This occurs when the
64 * virtual machine is terminated externally, for example with the
65 * SIGKILL signal on Unix or the TerminateProcess call on
66 * Microsoft Windows.The virtual machine may also abort if a native method goes awry
67 * by, for example, corrupting internal data structures or attempting to
68 * access nonexistent memory.If the virtual machine aborts then no
69 * guarantee can be made about whether or not any shutdown hooks will be
70 * run.
71 *
72 * @param hook
73 * An initialized but unstarted {@link Thread} object
74 *
75 * @throwsIllegalArgumentException
76 * If the specified hook has already been registered,
77 * or if it can be determined that the hook is already running or
78 * has already been run
79 *
80 * @throwsIllegalStateException
81 * If the virtual machine is already in the process
82 * of shutting down
83 *
84 * @throwsSecurityException
85 * If a security manager is present and it denies
86 * {@link RuntimePermission}("shutdownHooks")
87 *
88 * @see #removeShutdownHook
89 * @see #halt(int)
90 * @see #exit(int)
91 * @since 1.3
92 */
93 public void addShutdownHook(Thread hook) {
94 SecurityManager sm = System.getSecurityManager();
95 if (sm != null) {
96 sm.checkPermission(new RuntimePermission("shutdownHooks"));
97 }
98 Shutdown.add(hook);
99 }
再来看看Shutdow：
1 /* Add a new shutdown hook.Checks the shutdown state and the hook itself,
2 * but does not do any security checks.
3 */
4 static void add(Thread hook) {
5 synchronized (lock) {
6 if (state > RUNNING)
7 throw new IllegalStateException("Shutdown in progress");
8 if (hook.isAlive())
9 throw new IllegalArgumentException("Hook already running");
10 if (hooks == null) {
11 hooks = new HashSet(11);
12 hooks.add(new WrappedHook(hook));
13 Terminator.setup();
14 } else {
15 WrappedHook wh = new WrappedHook(hook);
16 if (hooks.contains(wh))
17 throw new IllegalArgumentException("Hook previously registered");
18 hooks.add(wh);
19 }
20 }
21 }
结论：
还是好多东西以前不知道，想起那个怪圈来了。
页:
[1]