--- a/src/org/eclipse/jetty/server/Server.java	Tue Oct 04 14:50:32 2016 -0600
+++ b/src/org/eclipse/jetty/server/Server.java	Tue Oct 04 15:55:02 2016 -0600
@@ -44,7 +44,6 @@
 import org.eclipse.jetty.util.component.LifeCycle;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.eclipse.jetty.util.thread.ShutdownThread;
 
 /* ------------------------------------------------------------ */
 /** Jetty HTTP Servlet Server.
@@ -65,7 +64,6 @@
 	public final ThreadPoolExecutor threadPool;
 	public final Connector connector;
 	private int _graceful=0;
-	private boolean _stopAtShutdown;
 	private boolean _dumpAfterStart=false;
 	private boolean _dumpBeforeStop=false;
 	private boolean _uncheckedPrintWriter=false;
@@ -93,32 +91,6 @@
 		return __version;
 	}
 
-	/* ------------------------------------------------------------ */
-	public boolean getStopAtShutdown()
-	{
-		return _stopAtShutdown;
-	}
-
-	/* ------------------------------------------------------------ */
-	public void setStopAtShutdown(boolean stop)
-	{
-		//if we now want to stop
-		if (stop)
-		{
-			//and we weren't stopping before
-			if (!_stopAtShutdown)
-			{  
-				//only register to stop if we're already started (otherwise we'll do it in doStart())
-				if (isStarted()) 
-					ShutdownThread.register(this);
-			}
-		}
-		else
-			ShutdownThread.deregister(this);
-		
-		_stopAtShutdown=stop;
-	}
-
 	/**
 	 * @return true if {@link #dumpStdErr()} is called after starting
 	 */
@@ -157,13 +129,6 @@
 	@Override
 	protected void doStart() throws Exception
 	{
-		if (getStopAtShutdown())
-		{
-			ShutdownThread.register(this);    
-		}
-		
-		ShutdownMonitor.getInstance().start(); // initialize
-
 		LOG.info("jetty-"+__version);
 		HttpGenerator.setServerVersion(__version);
 		
@@ -224,9 +189,6 @@
 		try {super.doStop(); } catch(Throwable e) { mex.add(e);}
 
 		mex.ifExceptionThrow();
-
-		if (getStopAtShutdown())
-			ShutdownThread.deregister(this);
 	}
 
 	/* ------------------------------------------------------------ */

--- a/src/org/eclipse/jetty/server/ShutdownMonitor.java	Tue Oct 04 14:50:32 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,384 +0,0 @@
-//
-//  ========================================================================
-//  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
-//  ------------------------------------------------------------------------
-//  All rights reserved. This program and the accompanying materials
-//  are made available under the terms of the Eclipse Public License v1.0
-//  and Apache License v2.0 which accompanies this distribution.
-//
-//      The Eclipse Public License is available at
-//      http://www.eclipse.org/legal/epl-v10.html
-//
-//      The Apache License v2.0 is available at
-//      http://www.opensource.org/licenses/apache2.0.php
-//
-//  You may elect to redistribute this code under either of these licenses.
-//  ========================================================================
-//
-
-package org.eclipse.jetty.server;
-
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.LineNumberReader;
-import java.io.OutputStream;
-import java.net.InetAddress;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.util.Properties;
-
-import org.eclipse.jetty.util.StringUtil;
-import org.eclipse.jetty.util.thread.ShutdownThread;
-
-/**
- * Shutdown/Stop Monitor thread.
- * <p>
- * This thread listens on the port specified by the STOP.PORT system parameter (defaults to -1 for not listening) for request authenticated with the key given
- * by the STOP.KEY system parameter (defaults to "eclipse") for admin requests.
- * <p>
- * If the stop port is set to zero, then a random port is assigned and the port number is printed to stdout.
- * <p>
- * Commands "stop" and "status" are currently supported.
- */
-public class ShutdownMonitor 
-{
-    // Implementation of safe lazy init, using Initialization on Demand Holder technique.
-    static class Holder
-    {
-        static ShutdownMonitor instance = new ShutdownMonitor();
-    }
-
-    public static ShutdownMonitor getInstance()
-    {
-        return Holder.instance;
-    }
-
-    /**
-     * ShutdownMonitorThread
-     *
-     * Thread for listening to STOP.PORT for command to stop Jetty.
-     * If ShowndownMonitor.exitVm is true, then Sytem.exit will also be
-     * called after the stop.
-     *
-     */
-    public class ShutdownMonitorThread extends Thread
-    {
-
-        public ShutdownMonitorThread ()
-        {
-            setDaemon(true);
-            setName("ShutdownMonitor");
-        }
-        
-        @Override
-        public void run()
-        {
-            if (serverSocket == null)
-            {
-                return;
-            }
-
-            while (serverSocket != null)
-            {
-                Socket socket = null;
-                try
-                {
-                    socket = serverSocket.accept();
-
-                    LineNumberReader lin = new LineNumberReader(new InputStreamReader(socket.getInputStream()));
-                    String receivedKey = lin.readLine();
-                    if (!key.equals(receivedKey))
-                    {
-                        System.err.println("Ignoring command with incorrect key");
-                        continue;
-                    }
-
-                    OutputStream out = socket.getOutputStream();
-
-                    String cmd = lin.readLine();
-                    debug("command=%s",cmd);
-                    if ("stop".equals(cmd))
-                    {
-                        // Graceful Shutdown
-                        debug("Issuing graceful shutdown..");
-                        ShutdownThread.getInstance().run();
-
-                        // Reply to client
-                        debug("Informing client that we are stopped.");
-                        out.write("Stopped\r\n".getBytes(StringUtil.__UTF8));
-                        out.flush();
-
-                        // Shutdown Monitor
-                        debug("Shutting down monitor");
-                        close(socket);
-                        socket = null;
-                        close(serverSocket);
-                        serverSocket = null;
-
-                        if (exitVm)
-                        {
-                            // Kill JVM
-                            debug("Killing JVM");
-                            System.exit(0);
-                        }
-                    }
-                    else if ("status".equals(cmd))
-                    {
-                        // Reply to client
-                        out.write("OK\r\n".getBytes(StringUtil.__UTF8));
-                        out.flush();
-                    }
-                }
-                catch (Exception e)
-                {
-                    debug(e);
-                    System.err.println(e.toString());
-                }
-                finally
-                {
-                    close(socket);
-                    socket = null;
-                }
-            }
-        }
-        
-        public void start()
-        {
-            if (isAlive())
-            {
-                System.err.printf("ShutdownMonitorThread already started");
-                return; // cannot start it again
-            }
-
-            startListenSocket();
-            
-            if (serverSocket == null)
-            {
-                return;
-            }
-            if (DEBUG)
-                System.err.println("Starting ShutdownMonitorThread");
-            super.start();
-        }
-        
-        private void startListenSocket()
-        {
-            if (port < 0)
-            {            
-                if (DEBUG)
-                    System.err.println("ShutdownMonitor not in use (port < 0): " + port);
-                return;
-            }
-
-            try
-            {
-                serverSocket = new ServerSocket(port,1,InetAddress.getByName("127.0.0.1"));
-                if (port == 0)
-                {
-                    // server assigned port in use
-                    port = serverSocket.getLocalPort();
-                    System.out.printf("STOP.PORT=%d%n",port);
-                }
-
-                if (key == null)
-                {
-                    // create random key
-                    key = Long.toString((long)(Long.MAX_VALUE * Math.random() + this.hashCode() + System.currentTimeMillis()),36);
-                    System.out.printf("STOP.KEY=%s%n",key);
-                }
-            }
-            catch (Exception e)
-            {
-                debug(e);
-                System.err.println("Error binding monitor port " + port + ": " + e.toString());
-                serverSocket = null;
-            }
-            finally
-            {
-                // establish the port and key that are in use
-                debug("STOP.PORT=%d",port);
-                debug("STOP.KEY=%s",key);
-                debug("%s",serverSocket);
-            }
-        }
-
-    }
-    
-    private boolean DEBUG;
-    private int port;
-    private String key;
-    private boolean exitVm;
-    private ServerSocket serverSocket;
-    private ShutdownMonitorThread thread;
-    
-    
-
-    /**
-     * Create a ShutdownMonitor using configuration from the System properties.
-     * <p>
-     * <code>STOP.PORT</code> = the port to listen on (empty, null, or values less than 0 disable the stop ability)<br>
-     * <code>STOP.KEY</code> = the magic key/passphrase to allow the stop (defaults to "eclipse")<br>
-     * <p>
-     * Note: server socket will only listen on localhost, and a successful stop will issue a System.exit() call.
-     */
-    private ShutdownMonitor()
-    {
-        Properties props = System.getProperties();
-
-        this.DEBUG = props.containsKey("DEBUG");
-
-        // Use values passed thru via /jetty-start/
-        this.port = Integer.parseInt(props.getProperty("STOP.PORT","-1"));
-        this.key = props.getProperty("STOP.KEY",null);
-        this.exitVm = true;
-    }
-
-    private void close(ServerSocket server)
-    {
-        if (server == null)
-        {
-            return;
-        }
-
-        try
-        {
-            server.close();
-        }
-        catch (IOException ignore)
-        {
-            /* ignore */
-        }
-    }
-
-    private void close(Socket socket)
-    {
-        if (socket == null)
-        {
-            return;
-        }
-
-        try
-        {
-            socket.close();
-        }
-        catch (IOException ignore)
-        {
-            /* ignore */
-        }
-    }
-
-    private void debug(String format, Object... args)
-    {
-        if (DEBUG)
-        {
-            System.err.printf("[ShutdownMonitor] " + format + "%n",args);
-        }
-    }
-
-    private void debug(Throwable t)
-    {
-        if (DEBUG)
-        {
-            t.printStackTrace(System.err);
-        }
-    }
-
-    public String getKey()
-    {
-        return key;
-    }
-
-    public int getPort()
-    {
-        return port;
-    }
-
-    public ServerSocket getServerSocket()
-    {
-        return serverSocket;
-    }
-
-    public boolean isExitVm()
-    {
-        return exitVm;
-    }
-
-
-    public void setDebug(boolean flag)
-    {
-        this.DEBUG = flag;
-    }
-
-    public void setExitVm(boolean exitVm)
-    {
-        synchronized (this)
-        {
-            if (thread != null && thread.isAlive())
-            {
-                throw new IllegalStateException("ShutdownMonitorThread already started");
-            }
-            this.exitVm = exitVm;
-        }
-    }
-
-    public void setKey(String key)
-    {
-        synchronized (this)
-        {
-            if (thread != null && thread.isAlive())
-            {
-                throw new IllegalStateException("ShutdownMonitorThread already started");
-            }
-            this.key = key;
-        }
-    }
-
-    public void setPort(int port)
-    {
-        synchronized (this)
-        {
-            if (thread != null && thread.isAlive())
-            {
-                throw new IllegalStateException("ShutdownMonitorThread already started");
-            }
-            this.port = port;
-        }
-    }
-
-    protected void start() throws Exception
-    {
-        ShutdownMonitorThread t = null;
-        synchronized (this)
-        {
-            if (thread != null && thread.isAlive())
-            {
-                System.err.printf("ShutdownMonitorThread already started");
-                return; // cannot start it again
-            }
-         
-            thread = new ShutdownMonitorThread();
-            t = thread;
-        }
-         
-        if (t != null)
-            t.start();
-    }
-
-
-    protected boolean isAlive ()
-    {
-        boolean result = false;
-        synchronized (this)
-        {
-            result = (thread != null && thread.isAlive());
-        }
-        return result;
-    }
-    
- 
-    @Override
-    public String toString()
-    {
-        return String.format("%s[port=%d]",this.getClass().getName(),port);
-    }
-}

--- a/src/org/eclipse/jetty/util/thread/ShutdownThread.java	Tue Oct 04 14:50:32 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,148 +0,0 @@
-//
-//  ========================================================================
-//  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
-//  ------------------------------------------------------------------------
-//  All rights reserved. This program and the accompanying materials
-//  are made available under the terms of the Eclipse Public License v1.0
-//  and Apache License v2.0 which accompanies this distribution.
-//
-//      The Eclipse Public License is available at
-//      http://www.eclipse.org/legal/epl-v10.html
-//
-//      The Apache License v2.0 is available at
-//      http://www.opensource.org/licenses/apache2.0.php
-//
-//  You may elect to redistribute this code under either of these licenses.
-//  ========================================================================
-//
-
-package org.eclipse.jetty.util.thread;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-import org.eclipse.jetty.util.component.Destroyable;
-import org.eclipse.jetty.util.component.LifeCycle;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-
-/* ------------------------------------------------------------ */
-/**
- * ShutdownThread is a shutdown hook thread implemented as 
- * singleton that maintains a list of lifecycle instances
- * that are registered with it and provides ability to stop
- * these lifecycles upon shutdown of the Java Virtual Machine 
- */
-public class ShutdownThread extends Thread
-{
-    private static final Logger LOG = LoggerFactory.getLogger(ShutdownThread.class);
-    private static final ShutdownThread _thread = new ShutdownThread();
-
-    private boolean _hooked;
-    private final List<LifeCycle> _lifeCycles = new CopyOnWriteArrayList<LifeCycle>();
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Default constructor for the singleton
-     * 
-     * Registers the instance as shutdown hook with the Java Runtime
-     */
-    private ShutdownThread()
-    {
-    }
-    
-    /* ------------------------------------------------------------ */
-    private synchronized void hook()
-    {
-        try
-        {
-            if (!_hooked)
-                Runtime.getRuntime().addShutdownHook(this);
-            _hooked=true;
-        }
-        catch(Exception e)
-        {
-            LOG.trace("",e);
-            LOG.info("shutdown already commenced");
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    private synchronized void unhook()
-    {
-        try
-        {
-            _hooked=false;
-            Runtime.getRuntime().removeShutdownHook(this);
-        }
-        catch(Exception e)
-        {
-            LOG.trace("",e);
-            LOG.debug("shutdown already commenced");
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * Returns the instance of the singleton
-     * 
-     * @return the singleton instance of the {@link ShutdownThread}
-     */
-    public static ShutdownThread getInstance()
-    {
-        return _thread;
-    }
-
-    /* ------------------------------------------------------------ */
-    public static synchronized void register(LifeCycle... lifeCycles)
-    {
-        _thread._lifeCycles.addAll(Arrays.asList(lifeCycles));
-        if (_thread._lifeCycles.size()>0)
-            _thread.hook();
-    }
-
-    /* ------------------------------------------------------------ */
-    public static synchronized void register(int index, LifeCycle... lifeCycles)
-    {
-        _thread._lifeCycles.addAll(index,Arrays.asList(lifeCycles));
-        if (_thread._lifeCycles.size()>0)
-            _thread.hook();
-    }
-    
-    /* ------------------------------------------------------------ */
-    public static synchronized void deregister(LifeCycle lifeCycle)
-    {
-        _thread._lifeCycles.remove(lifeCycle);
-        if (_thread._lifeCycles.size()==0)
-            _thread.unhook();
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void run()
-    {
-        for (LifeCycle lifeCycle : _thread._lifeCycles)
-        {
-            try
-            {
-                if (lifeCycle.isStarted())
-                {
-                    lifeCycle.stop();
-                    LOG.debug("Stopped {}",lifeCycle);
-                }
-                
-                if (lifeCycle instanceof Destroyable)
-                {
-                    ((Destroyable)lifeCycle).destroy();
-                    LOG.debug("Destroyed {}",lifeCycle);
-                }
-            }
-            catch (Exception ex)
-            {
-                LOG.debug("",ex);
-            }
-        }
-    }
-}