java程序的smooth关闭策略可以采用hook跟观察者的模式实现
无限等状态，如果状态出现可以关闭的事件则进行关闭
虚拟机的关闭通过钩子调用关闭，如果关闭失败，在超时时间内强制杀掉jvm
状态类
public interface State { public boolean isStoppable(); }
package com.s.stat; /** * A Stateful job implements this interface so that * it's state can be discovered. State is used to * control the flow of execution within Oddjob, as * well as being a way of informing client applications * of progress. * * @author Rob Gordon */ public interface Stateful { /** * Add a job state listener. * * @param listener The listener. * */ public void addStateListener(StateListener listener) ; /** * Remove a job state listener. * * @param listener The listener. */ public void removeStateListener(StateListener listener); /** * Get the last state event. * * @return The last State Event */ public StateEvent lastStateEvent(); }
package com.s.stat; import java.io.Serializable; import java.util.Date; import java.util.EventObject; /** * An instance of this class is produced when a job state changes. It is * passed to all JobStateListeners. * * @author Rob Gordon */ public class StateEvent extends EventObject implements Serializable { private static final long serialVersionUID = 20051026; static final String REPLACEMENT_EXCEPTION_TEXT = "Exception is not serializable, message is: "; private State state; private Date time; private Throwable exception; /** * Used to replace a non serializable exception. * */ class ExceptionReplacement extends Exception { private static final long serialVersionUID = 20051217; public ExceptionReplacement(Throwable replacing) { super(REPLACEMENT_EXCEPTION_TEXT + replacing.getMessage()); super.setStackTrace(exception.getStackTrace()); } } /** * Constructor. * * @param job The source of the event. * @param jobState The state. * @param time the Time of the event. * @param exception The exception if applicable, or null otherwise. */ public StateEvent(Stateful job, State jobState, Date time, Throwable exception) { super(job); if (jobState == null) { throw new NullPointerException("JobState can not be null!"); } this.state = jobState; this.time = time; this.exception = exception; } /** * Constructor. * * @param job The source of the event. * @param jobState The state. * @param exception The exception if applicable, or null otherwise. */ public StateEvent(Stateful job, State jobState, Throwable exception) { this(job, jobState, new Date(), exception); } /** * Constructor. * * @param job The source of the event. * @param jobState The state. */ public StateEvent(Stateful job, State jobState) { this(job, jobState, null); } @Override public Stateful getSource() { return (Stateful) super.getSource(); } /** * Get the job state. * * @return The job state. */ public State getState() { return state; } /** * Get the exception if applicable, null otherwise. * * @return The exception of null. */ public Throwable getException() { return exception; } /** * Get the time of the event.. * * @return The time. */ public Date getTime() { return time; } /** * Override toString. */ public String toString() { return "JobStateEvent, source=" + getSource() + ", " + state; } }
package com.s.stat; /** * Implementors of this interface are able to listen to state events. * * @author Rob Gordon */ public interface StateListener { /** * Triggered when the job state changes. * * @param event The job state event. */ public void jobStateChange(StateEvent event); }
package com.s; import com.s.stat.StateEvent; import com.s.stat.StateListener; import com.s.stat.Stateful; public class Runner implements Runnable{ public static final String KILLER_TIMEOUT_PROPERTY = "shutdown.killer.timeout"; public static final long DEFAULT_KILLER_TIMEOUT = 15000L; /** Flag if program is being destroyed from the Shutdown Hook. */ private volatile boolean destroying = false; /** The killer thread time out. */ private final long killerTimeout; public Runner() { String timeoutProperty = System.getProperty(KILLER_TIMEOUT_PROPERTY); if (timeoutProperty == null) { killerTimeout = DEFAULT_KILLER_TIMEOUT; } else { killerTimeout = Long.parseLong(timeoutProperty); } } @Override public void run() { // TODO Auto-generated method stub Runtime.getRuntime().addShutdownHook(new ShutdownHook()); // Possibly wait for Oddjob to be in a stopped state. new StopWait(new Stateful() { @Override public void removeStateListener(StateListener listener) { // TODO Auto-generated method stub } @Override public StateEvent lastStateEvent() { // TODO Auto-generated method stub return null; } @Override public void addStateListener(StateListener listener) { // TODO Auto-generated method stub } }, Long.MAX_VALUE).run(); // 调用程序的stop } /** * shutdown hook. * <p> * This Class has evolved quite a lot though trial and error due to * a lack of understanding of JVM shutdown. Should this thread be a * daemon? Current thinking is no because you don't want other daemon * threads to terminate until has been shutdown properly. * */ class ShutdownHook extends Thread { /** Killer thread will forcibly halt if it hasn't terminated * cleanly. */ private Thread killer; /* * (non-Javadoc) * @see java.lang.Thread#run() */ public void run() { // logger.info("Shutdown Hook Executing."); // killer will just kill process if we can't stop in 15 sec killer = new Thread(new Runnable() { public void run() { try { Thread.sleep(killerTimeout); } catch (InterruptedException e) { // logger.debug("Killer thread interrupted and terminating."); return; } // logger.error("Failed to stop Oddjob nicely, using halt(-1)"); Runtime.getRuntime().halt(-1); } }); // start the killer. Not sure it really need to be daemon but // it does no harm. // logger.debug("Starting killer thread."); killer.setDaemon(true); killer.start(); // 调用程序的关闭 // Nothing's hanging so we don't need our killer. //TODO 判断程序是否调用自身的关闭程序，如果成功则单端killer // killer.interrupt(); } } }
package com.s; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; import com.s.stat.IsStoppable; import com.s.stat.State; import com.s.stat.StateEvent; import com.s.stat.StateListener; import com.s.stat.Stateful; /** * A utility class to provide wait until stopped functionality. * <p> * The default timeout is 5 seconds before a {@link FailedToStopException} * is thrown. * * @author rob * */ public class StopWait { private final Stateful stateful; private final long timeout; /** * Constructor with default timeout. * * @param stateful The thing to wait until stopped. */ public StopWait(Stateful stateful) { this(stateful, 5000); } /** * Constructor where timeout can be specified. * * @param stateful The thing to wait until stopped. * @param timeout The timeout. Note that a timeout of 0 or less is * no timeout. */ public StopWait(Stateful stateful, long timeout) { this.stateful = stateful; this.timeout = timeout; } /** * Run the stop wait. This will block until the job stops or the * timeout occurs. * * @throws FailedToStopException If timeout occurs. */ public void run() { if (new IsStoppable().test( stateful.lastStateEvent().getState())) { doWait(); } } private void doWait() { final BlockingQueue<State> handoff = new LinkedBlockingQueue<State>(); class StopListener implements StateListener { @Override public void jobStateChange(StateEvent event) { handoff.add(event.getState()); } }; StopListener listener = new StopListener(); stateful.addStateListener(listener); try { while (true) { State state = handoff.poll(timeout, TimeUnit.MILLISECONDS); if (state == null) { } if (!state.isStoppable()) { return; } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { stateful.removeStateListener(listener); } } }