changeset 865:6b210bb66c63

remove ThreadPool
author Franklin Schmidt <fschmidt@gmail.com>
date Sun, 02 Oct 2016 20:38:06 -0600
parents e21ca9878a10
children f8c7b718f513
files src/org/eclipse/jetty/io/nio/SelectChannelEndPoint.java src/org/eclipse/jetty/io/nio/SelectorManager.java src/org/eclipse/jetty/server/AbstractConnector.java src/org/eclipse/jetty/server/AsyncContinuation.java src/org/eclipse/jetty/server/Connector.java src/org/eclipse/jetty/server/Server.java src/org/eclipse/jetty/server/bio/SocketConnector.java src/org/eclipse/jetty/server/handler/HandlerCollection.java src/org/eclipse/jetty/server/nio/BlockingChannelConnector.java src/org/eclipse/jetty/server/nio/InheritedChannelConnector.java src/org/eclipse/jetty/server/nio/SelectChannelConnector.java src/org/eclipse/jetty/util/BlockingArrayQueue.java src/org/eclipse/jetty/util/thread/ExecutorThreadPool.java src/org/eclipse/jetty/util/thread/QueuedThreadPool.java src/org/eclipse/jetty/util/thread/ThreadPool.java
diffstat 15 files changed, 2932 insertions(+), 4617 deletions(-) [+]
line wrap: on
line diff
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/io/nio/SelectChannelEndPoint.java
--- a/src/org/eclipse/jetty/io/nio/SelectChannelEndPoint.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/io/nio/SelectChannelEndPoint.java	Sun Oct 02 20:38:06 2016 -0600
@@ -25,6 +25,7 @@
 import java.nio.channels.SelectionKey;
 import java.nio.channels.SocketChannel;
 import java.util.Locale;
+import java.util.concurrent.RejectedExecutionException;
 
 import org.eclipse.jetty.io.AsyncEndPoint;
 import org.eclipse.jetty.io.Buffer;
@@ -42,827 +43,827 @@
  */
 public class SelectChannelEndPoint extends ChannelEndPoint implements AsyncEndPoint, ConnectedEndPoint
 {
-    public static final Logger LOG=LoggerFactory.getLogger("org.eclipse.jetty.io.nio");
+	public static final Logger LOG=LoggerFactory.getLogger("org.eclipse.jetty.io.nio");
 
-    private final boolean WORK_AROUND_JVM_BUG_6346658 = System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("win");
-    private final SelectorManager.SelectSet _selectSet;
-    private final SelectorManager _manager;
-    private  SelectionKey _key;
-    private final Runnable _handler = new Runnable()
-        {
-            public void run() { handle(); }
-        };
+	private final boolean WORK_AROUND_JVM_BUG_6346658 = System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("win");
+	private final SelectorManager.SelectSet _selectSet;
+	private final SelectorManager _manager;
+	private  SelectionKey _key;
+	private final Runnable _handler = new Runnable()
+		{
+			public void run() { handle(); }
+		};
 
-    /** The desired value for {@link SelectionKey#interestOps()} */
-    private int _interestOps;
+	/** The desired value for {@link SelectionKey#interestOps()} */
+	private int _interestOps;
 
-    /**
-     * The connection instance is the handler for any IO activity on the endpoint.
-     * There is a different type of connection for HTTP, AJP, WebSocket and
-     * ProxyConnect.   The connection may change for an SCEP as it is upgraded
-     * from HTTP to proxy connect or websocket.
-     */
-    private volatile AsyncConnection _connection;
+	/**
+	 * The connection instance is the handler for any IO activity on the endpoint.
+	 * There is a different type of connection for HTTP, AJP, WebSocket and
+	 * ProxyConnect.   The connection may change for an SCEP as it is upgraded
+	 * from HTTP to proxy connect or websocket.
+	 */
+	private volatile AsyncConnection _connection;
 
-    private static final int STATE_NEEDS_DISPATCH=-1;
-    private static final int STATE_UNDISPATCHED=0;
-    private static final int STATE_DISPATCHED=1;
-    private static final int STATE_ASYNC=2;
-    private int _state;
-    
-    private boolean _onIdle;
+	private static final int STATE_NEEDS_DISPATCH=-1;
+	private static final int STATE_UNDISPATCHED=0;
+	private static final int STATE_DISPATCHED=1;
+	private static final int STATE_ASYNC=2;
+	private int _state;
+	
+	private boolean _onIdle;
 
-    /** true if the last write operation succeed and wrote all offered bytes */
-    private volatile boolean _writable = true;
+	/** true if the last write operation succeed and wrote all offered bytes */
+	private volatile boolean _writable = true;
 
 
-    /** True if a thread has is blocked in {@link #blockReadable(long)} */
-    private boolean _readBlocked;
+	/** True if a thread has is blocked in {@link #blockReadable(long)} */
+	private boolean _readBlocked;
 
-    /** True if a thread has is blocked in {@link #blockWritable(long)} */
-    private boolean _writeBlocked;
+	/** True if a thread has is blocked in {@link #blockWritable(long)} */
+	private boolean _writeBlocked;
 
-    /** true if {@link SelectSet#destroyEndPoint(SelectChannelEndPoint)} has not been called */
-    private boolean _open;
+	/** true if {@link SelectSet#destroyEndPoint(SelectChannelEndPoint)} has not been called */
+	private boolean _open;
 
-    private volatile long _idleTimestamp;
-    private volatile boolean _checkIdle;
-    
-    private boolean _interruptable;
+	private volatile long _idleTimestamp;
+	private volatile boolean _checkIdle;
+	
+	private boolean _interruptable;
 
-    private boolean _ishut;
+	private boolean _ishut;
 
-    /* ------------------------------------------------------------ */
-    public SelectChannelEndPoint(SocketChannel channel, SelectSet selectSet, SelectionKey key, int maxIdleTime)
-        throws IOException
-    {
-        super(channel, maxIdleTime);
+	/* ------------------------------------------------------------ */
+	public SelectChannelEndPoint(SocketChannel channel, SelectSet selectSet, SelectionKey key, int maxIdleTime)
+		throws IOException
+	{
+		super(channel, maxIdleTime);
 
-        _manager = selectSet.getManager();
-        _selectSet = selectSet;
-        _state=STATE_UNDISPATCHED;
-        _onIdle=false;
-        _open=true;
-        _key = key;
+		_manager = selectSet.getManager();
+		_selectSet = selectSet;
+		_state=STATE_UNDISPATCHED;
+		_onIdle=false;
+		_open=true;
+		_key = key;
 
-        setCheckForIdle(true);
-    }
+		setCheckForIdle(true);
+	}
 
-    /* ------------------------------------------------------------ */
-    public SelectionKey getSelectionKey()
-    {
-        synchronized (this)
-        {
-            return _key;
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public SelectionKey getSelectionKey()
+	{
+		synchronized (this)
+		{
+			return _key;
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public SelectorManager getSelectManager()
-    {
-        return _manager;
-    }
+	/* ------------------------------------------------------------ */
+	public SelectorManager getSelectManager()
+	{
+		return _manager;
+	}
 
-    /* ------------------------------------------------------------ */
-    public Connection getConnection()
-    {
-        return _connection;
-    }
+	/* ------------------------------------------------------------ */
+	public Connection getConnection()
+	{
+		return _connection;
+	}
 
-    /* ------------------------------------------------------------ */
-    public void setConnection(Connection connection)
-    {
-        Connection old=_connection;
-        _connection=(AsyncConnection)connection;
-        if (old!=null && old!=_connection)
-            _manager.endPointUpgraded(this,old);
-    }
+	/* ------------------------------------------------------------ */
+	public void setConnection(Connection connection)
+	{
+		Connection old=_connection;
+		_connection=(AsyncConnection)connection;
+		if (old!=null && old!=_connection)
+			_manager.endPointUpgraded(this,old);
+	}
 
-    /* ------------------------------------------------------------ */
-    public long getIdleTimestamp()
-    {
-        return _idleTimestamp;
-    }
+	/* ------------------------------------------------------------ */
+	public long getIdleTimestamp()
+	{
+		return _idleTimestamp;
+	}
 
-    /* ------------------------------------------------------------ */
-    /** Called by selectSet to schedule handling
-     *
-     */
-    public void schedule()
-    {
-        synchronized (this)
-        {
-            // If there is no key, then do nothing
-            if (_key == null || !_key.isValid())
-            {
-                _readBlocked=false;
-                _writeBlocked=false;
-                this.notifyAll();
-                return;
-            }
+	/* ------------------------------------------------------------ */
+	/** Called by selectSet to schedule handling
+	 *
+	 */
+	public void schedule()
+	{
+		synchronized (this)
+		{
+			// If there is no key, then do nothing
+			if (_key == null || !_key.isValid())
+			{
+				_readBlocked=false;
+				_writeBlocked=false;
+				this.notifyAll();
+				return;
+			}
 
-            // If there are threads dispatched reading and writing
-            if (_readBlocked || _writeBlocked)
-            {
-                // assert _dispatched;
-                if (_readBlocked && _key.isReadable())
-                    _readBlocked=false;
-                if (_writeBlocked && _key.isWritable())
-                    _writeBlocked=false;
+			// If there are threads dispatched reading and writing
+			if (_readBlocked || _writeBlocked)
+			{
+				// assert _dispatched;
+				if (_readBlocked && _key.isReadable())
+					_readBlocked=false;
+				if (_writeBlocked && _key.isWritable())
+					_writeBlocked=false;
 
-                // wake them up is as good as a dispatched.
-                this.notifyAll();
+				// wake them up is as good as a dispatched.
+				this.notifyAll();
 
-                // we are not interested in further selecting
-                _key.interestOps(0);
-                if (_state<STATE_DISPATCHED)
-                    updateKey();
-                return;
-            }
+				// we are not interested in further selecting
+				_key.interestOps(0);
+				if (_state<STATE_DISPATCHED)
+					updateKey();
+				return;
+			}
 
-            // Remove writeable op
-            if ((_key.readyOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE && (_key.interestOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE)
-            {
-                // Remove writeable op
-                _interestOps = _key.interestOps() & ~SelectionKey.OP_WRITE;
-                _key.interestOps(_interestOps);
-                _writable = true; // Once writable is in ops, only removed with dispatch.
-            }
+			// Remove writeable op
+			if ((_key.readyOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE && (_key.interestOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE)
+			{
+				// Remove writeable op
+				_interestOps = _key.interestOps() & ~SelectionKey.OP_WRITE;
+				_key.interestOps(_interestOps);
+				_writable = true; // Once writable is in ops, only removed with dispatch.
+			}
 
-            // If dispatched, then deregister interest
-            if (_state>=STATE_DISPATCHED)
-                _key.interestOps(0);
-            else
-            {
-                // other wise do the dispatch
-                dispatch();
-                if (_state>=STATE_DISPATCHED && !_selectSet.getManager().isDeferringInterestedOps0())
-                {
-                    _key.interestOps(0);
-                }
-            }
-        }
-    }
+			// If dispatched, then deregister interest
+			if (_state>=STATE_DISPATCHED)
+				_key.interestOps(0);
+			else
+			{
+				// other wise do the dispatch
+				dispatch();
+				if (_state>=STATE_DISPATCHED && !_selectSet.getManager().isDeferringInterestedOps0())
+				{
+					_key.interestOps(0);
+				}
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void asyncDispatch()
-    {
-        synchronized(this)
-        {
-            switch(_state)
-            {
-                case STATE_NEEDS_DISPATCH:
-                case STATE_UNDISPATCHED:
-                    dispatch();
-                    break;
-                    
-                case STATE_DISPATCHED:
-                case STATE_ASYNC:
-                    _state=STATE_ASYNC;
-                    break;
-            }
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public void asyncDispatch()
+	{
+		synchronized(this)
+		{
+			switch(_state)
+			{
+				case STATE_NEEDS_DISPATCH:
+				case STATE_UNDISPATCHED:
+					dispatch();
+					break;
+					
+				case STATE_DISPATCHED:
+				case STATE_ASYNC:
+					_state=STATE_ASYNC;
+					break;
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void dispatch()
-    {
-        synchronized(this)
-        {
-            if (_state<=STATE_UNDISPATCHED)
-            {
-                if (_onIdle)
-                    _state = STATE_NEEDS_DISPATCH;
-                else
-                {
-                    _state = STATE_DISPATCHED;
-                    boolean dispatched = _manager.dispatch(_handler);
-                    if(!dispatched)
-                    {
-                        _state = STATE_NEEDS_DISPATCH;
-                        LOG.warn("Dispatched Failed! "+this+" to "+_manager);
-                        updateKey();
-                    }
-                }
-            }
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public void dispatch()
+	{
+		synchronized(this)
+		{
+			if (_state<=STATE_UNDISPATCHED)
+			{
+				if (_onIdle)
+					_state = STATE_NEEDS_DISPATCH;
+				else
+				{
+					_state = STATE_DISPATCHED;
+					try {
+						_manager.execute(_handler);
+					} catch(RejectedExecutionException e) {
+						_state = STATE_NEEDS_DISPATCH;
+						LOG.warn("Dispatched Failed! "+this+" to "+_manager);
+						updateKey();
+					}
+				}
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * Called when a dispatched thread is no longer handling the endpoint.
-     * The selection key operations are updated.
-     * @return If false is returned, the endpoint has been redispatched and
-     * thread must keep handling the endpoint.
-     */
-    protected boolean undispatch()
-    {
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case STATE_ASYNC:
-                    _state=STATE_DISPATCHED;
-                    return false;
+	/* ------------------------------------------------------------ */
+	/**
+	 * Called when a dispatched thread is no longer handling the endpoint.
+	 * The selection key operations are updated.
+	 * @return If false is returned, the endpoint has been redispatched and
+	 * thread must keep handling the endpoint.
+	 */
+	protected boolean undispatch()
+	{
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case STATE_ASYNC:
+					_state=STATE_DISPATCHED;
+					return false;
 
-                default:
-                    _state=STATE_UNDISPATCHED;
-                    updateKey();
-                    return true;
-            }
-        }
-    }
+				default:
+					_state=STATE_UNDISPATCHED;
+					updateKey();
+					return true;
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void cancelTimeout(Task task)
-    {
-        getSelectSet().cancelTimeout(task);
-    }
+	/* ------------------------------------------------------------ */
+	public void cancelTimeout(Task task)
+	{
+		getSelectSet().cancelTimeout(task);
+	}
 
-    /* ------------------------------------------------------------ */
-    public void scheduleTimeout(Task task, long timeoutMs)
-    {
-        getSelectSet().scheduleTimeout(task,timeoutMs);
-    }
+	/* ------------------------------------------------------------ */
+	public void scheduleTimeout(Task task, long timeoutMs)
+	{
+		getSelectSet().scheduleTimeout(task,timeoutMs);
+	}
 
-    /* ------------------------------------------------------------ */
-    public void setCheckForIdle(boolean check)
-    {
-        if (check)
-        {
-            _idleTimestamp=System.currentTimeMillis();
-            _checkIdle=true;
-        }
-        else
-            _checkIdle=false;
-    }
+	/* ------------------------------------------------------------ */
+	public void setCheckForIdle(boolean check)
+	{
+		if (check)
+		{
+			_idleTimestamp=System.currentTimeMillis();
+			_checkIdle=true;
+		}
+		else
+			_checkIdle=false;
+	}
 
-    /* ------------------------------------------------------------ */
-    public boolean isCheckForIdle()
-    {
-        return _checkIdle;
-    }
+	/* ------------------------------------------------------------ */
+	public boolean isCheckForIdle()
+	{
+		return _checkIdle;
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void notIdle()
-    {
-        _idleTimestamp=System.currentTimeMillis();
-    }
+	/* ------------------------------------------------------------ */
+	protected void notIdle()
+	{
+		_idleTimestamp=System.currentTimeMillis();
+	}
 
-    /* ------------------------------------------------------------ */
-    public void checkIdleTimestamp(long now)
-    {
-        if (isCheckForIdle() && _maxIdleTime>0)
-        {
-            final long idleForMs=now-_idleTimestamp;
+	/* ------------------------------------------------------------ */
+	public void checkIdleTimestamp(long now)
+	{
+		if (isCheckForIdle() && _maxIdleTime>0)
+		{
+			final long idleForMs=now-_idleTimestamp;
 
-            if (idleForMs>_maxIdleTime)
-            {
-                // Don't idle out again until onIdleExpired task completes.
-                setCheckForIdle(false);
-                _manager.dispatch(new Runnable()
-                {
-                    public void run()
-                    {
-                        try
-                        {
-                            onIdleExpired(idleForMs);
-                        }
-                        finally
-                        {
-                            setCheckForIdle(true);
-                        }
-                    }
-                });
-            }
-        }
-    }
+			if (idleForMs>_maxIdleTime)
+			{
+				// Don't idle out again until onIdleExpired task completes.
+				setCheckForIdle(false);
+				_manager.execute(new Runnable()
+				{
+					public void run()
+					{
+						try
+						{
+							onIdleExpired(idleForMs);
+						}
+						finally
+						{
+							setCheckForIdle(true);
+						}
+					}
+				});
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void onIdleExpired(long idleForMs)
-    {
-        try
-        {
-            synchronized (this)
-            {
-                _onIdle=true;
-            }
+	/* ------------------------------------------------------------ */
+	public void onIdleExpired(long idleForMs)
+	{
+		try
+		{
+			synchronized (this)
+			{
+				_onIdle=true;
+			}
 
-            _connection.onIdleExpired(idleForMs);
-        }
-        finally
-        {
-            synchronized (this)
-            {
-                _onIdle=false;
-                if (_state==STATE_NEEDS_DISPATCH)
-                    dispatch();
-            }
-        }
-    }
+			_connection.onIdleExpired(idleForMs);
+		}
+		finally
+		{
+			synchronized (this)
+			{
+				_onIdle=false;
+				if (_state==STATE_NEEDS_DISPATCH)
+					dispatch();
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    @Override
-    public int fill(Buffer buffer) throws IOException
-    {
-        int fill=super.fill(buffer);
-        if (fill>0)
-            notIdle();
-        return fill;
-    }
+	/* ------------------------------------------------------------ */
+	@Override
+	public int fill(Buffer buffer) throws IOException
+	{
+		int fill=super.fill(buffer);
+		if (fill>0)
+			notIdle();
+		return fill;
+	}
 
-    /* ------------------------------------------------------------ */
-    @Override
-    public int flush(Buffer header, Buffer buffer, Buffer trailer) throws IOException
-    {
-        int l = super.flush(header, buffer, trailer);
+	/* ------------------------------------------------------------ */
+	@Override
+	public int flush(Buffer header, Buffer buffer, Buffer trailer) throws IOException
+	{
+		int l = super.flush(header, buffer, trailer);
 
-        // If there was something to write and it wasn't written, then we are not writable.
-        if (l==0 && ( header!=null && header.hasContent() || buffer!=null && buffer.hasContent() || trailer!=null && trailer.hasContent()))
-        {
-            synchronized (this)
-            {   
-                _writable=false;
-                if (_state<STATE_DISPATCHED)
-                    updateKey();
-            }
-        }
-        else if (l>0)
-        {
-            _writable=true;
-            notIdle();
-        }
-        return l;
-    }
+		// If there was something to write and it wasn't written, then we are not writable.
+		if (l==0 && ( header!=null && header.hasContent() || buffer!=null && buffer.hasContent() || trailer!=null && trailer.hasContent()))
+		{
+			synchronized (this)
+			{   
+				_writable=false;
+				if (_state<STATE_DISPATCHED)
+					updateKey();
+			}
+		}
+		else if (l>0)
+		{
+			_writable=true;
+			notIdle();
+		}
+		return l;
+	}
 
-    /* ------------------------------------------------------------ */
-    /*
-     */
-    @Override
-    public int flush(Buffer buffer) throws IOException
-    {
-        int l = super.flush(buffer);
+	/* ------------------------------------------------------------ */
+	/*
+	 */
+	@Override
+	public int flush(Buffer buffer) throws IOException
+	{
+		int l = super.flush(buffer);
 
-        // If there was something to write and it wasn't written, then we are not writable.
-        if (l==0 && buffer!=null && buffer.hasContent())
-        {
-            synchronized (this)
-            {   
-                _writable=false;
-                if (_state<STATE_DISPATCHED)
-                    updateKey();
-            }
-        }
-        else if (l>0)
-        {
-            _writable=true;
-            notIdle();
-        }
+		// If there was something to write and it wasn't written, then we are not writable.
+		if (l==0 && buffer!=null && buffer.hasContent())
+		{
+			synchronized (this)
+			{   
+				_writable=false;
+				if (_state<STATE_DISPATCHED)
+					updateKey();
+			}
+		}
+		else if (l>0)
+		{
+			_writable=true;
+			notIdle();
+		}
 
-        return l;
-    }
+		return l;
+	}
 
-    /* ------------------------------------------------------------ */
-    /*
-     * Allows thread to block waiting for further events.
-     */
-    @Override
-    public boolean blockReadable(long timeoutMs) throws IOException
-    {
-        synchronized (this)
-        {
-            if (isInputShutdown())
-                throw new EofException();
+	/* ------------------------------------------------------------ */
+	/*
+	 * Allows thread to block waiting for further events.
+	 */
+	@Override
+	public boolean blockReadable(long timeoutMs) throws IOException
+	{
+		synchronized (this)
+		{
+			if (isInputShutdown())
+				throw new EofException();
 
-            long now=_selectSet.getNow();
-            long end=now+timeoutMs;
-            boolean check=isCheckForIdle();
-            setCheckForIdle(true);
-            try
-            {
-                _readBlocked=true;
-                while (!isInputShutdown() && _readBlocked)
-                {
-                    try
-                    {
-                        updateKey();
-                        this.wait(timeoutMs>0?(end-now):10000);
-                    }
-                    catch (final InterruptedException e)
-                    {
-                        LOG.warn("",e);
-                        if (_interruptable)
-                            throw new InterruptedIOException(){{this.initCause(e);}};
-                    }
-                    finally
-                    {
-                        now=_selectSet.getNow();
-                    }
+			long now=_selectSet.getNow();
+			long end=now+timeoutMs;
+			boolean check=isCheckForIdle();
+			setCheckForIdle(true);
+			try
+			{
+				_readBlocked=true;
+				while (!isInputShutdown() && _readBlocked)
+				{
+					try
+					{
+						updateKey();
+						this.wait(timeoutMs>0?(end-now):10000);
+					}
+					catch (final InterruptedException e)
+					{
+						LOG.warn("",e);
+						if (_interruptable)
+							throw new InterruptedIOException(){{this.initCause(e);}};
+					}
+					finally
+					{
+						now=_selectSet.getNow();
+					}
 
-                    if (_readBlocked && timeoutMs>0 && now>=end)
-                        return false;
-                }
-            }
-            finally
-            {
-                _readBlocked=false;
-                setCheckForIdle(check);
-            }
-        }
-        return true;
-    }
+					if (_readBlocked && timeoutMs>0 && now>=end)
+						return false;
+				}
+			}
+			finally
+			{
+				_readBlocked=false;
+				setCheckForIdle(check);
+			}
+		}
+		return true;
+	}
 
-    /* ------------------------------------------------------------ */
-    /*
-     * Allows thread to block waiting for further events.
-     */
-    @Override
-    public boolean blockWritable(long timeoutMs) throws IOException
-    {
-        synchronized (this)
-        {
-            if (isOutputShutdown())
-                throw new EofException();
+	/* ------------------------------------------------------------ */
+	/*
+	 * Allows thread to block waiting for further events.
+	 */
+	@Override
+	public boolean blockWritable(long timeoutMs) throws IOException
+	{
+		synchronized (this)
+		{
+			if (isOutputShutdown())
+				throw new EofException();
 
-            long now=_selectSet.getNow();
-            long end=now+timeoutMs;
-            boolean check=isCheckForIdle();
-            setCheckForIdle(true);
-            try
-            {
-                _writeBlocked=true;
-                while (_writeBlocked && !isOutputShutdown())
-                {
-                    try
-                    {
-                        updateKey();
-                        this.wait(timeoutMs>0?(end-now):10000);
-                    }
-                    catch (final InterruptedException e)
-                    {
-                        LOG.warn("",e);
-                        if (_interruptable)
-                            throw new InterruptedIOException(){{this.initCause(e);}};
-                    }
-                    finally
-                    {
-                        now=_selectSet.getNow();
-                    }
-                    if (_writeBlocked && timeoutMs>0 && now>=end)
-                        return false;
-                }
-            }
-            finally
-            {
-                _writeBlocked=false;
-                setCheckForIdle(check);
-            }
-        }
-        return true;
-    }
+			long now=_selectSet.getNow();
+			long end=now+timeoutMs;
+			boolean check=isCheckForIdle();
+			setCheckForIdle(true);
+			try
+			{
+				_writeBlocked=true;
+				while (_writeBlocked && !isOutputShutdown())
+				{
+					try
+					{
+						updateKey();
+						this.wait(timeoutMs>0?(end-now):10000);
+					}
+					catch (final InterruptedException e)
+					{
+						LOG.warn("",e);
+						if (_interruptable)
+							throw new InterruptedIOException(){{this.initCause(e);}};
+					}
+					finally
+					{
+						now=_selectSet.getNow();
+					}
+					if (_writeBlocked && timeoutMs>0 && now>=end)
+						return false;
+				}
+			}
+			finally
+			{
+				_writeBlocked=false;
+				setCheckForIdle(check);
+			}
+		}
+		return true;
+	}
 
-    /* ------------------------------------------------------------ */
-    /** Set the interruptable mode of the endpoint.
-     * If set to false (default), then interrupts are assumed to be spurious 
-     * and blocking operations continue unless the endpoint has been closed.
-     * If true, then interrupts of blocking operations result in InterruptedIOExceptions
-     * being thrown.
-     * @param interupable
-     */
-    public void setInterruptable(boolean interupable)
-    {
-        synchronized (this)
-        {
-            _interruptable=interupable;
-        }
-    }
+	/* ------------------------------------------------------------ */
+	/** Set the interruptable mode of the endpoint.
+	 * If set to false (default), then interrupts are assumed to be spurious 
+	 * and blocking operations continue unless the endpoint has been closed.
+	 * If true, then interrupts of blocking operations result in InterruptedIOExceptions
+	 * being thrown.
+	 * @param interupable
+	 */
+	public void setInterruptable(boolean interupable)
+	{
+		synchronized (this)
+		{
+			_interruptable=interupable;
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public boolean isInterruptable()
-    {
-        return _interruptable;
-    }
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.io.AsyncEndPoint#scheduleWrite()
-     */
-    public void scheduleWrite()
-    {
-        if (_writable)
-            LOG.debug("Required scheduleWrite {}",this);
+	/* ------------------------------------------------------------ */
+	public boolean isInterruptable()
+	{
+		return _interruptable;
+	}
+	
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.io.AsyncEndPoint#scheduleWrite()
+	 */
+	public void scheduleWrite()
+	{
+		if (_writable)
+			LOG.debug("Required scheduleWrite {}",this);
 
-        _writable=false;
-        updateKey();
-    }
+		_writable=false;
+		updateKey();
+	}
 
-    /* ------------------------------------------------------------ */
-    public boolean isWritable()
-    {
-        return _writable;
-    }
+	/* ------------------------------------------------------------ */
+	public boolean isWritable()
+	{
+		return _writable;
+	}
 
-    /* ------------------------------------------------------------ */
-    public boolean hasProgressed()
-    {
-        return false;
-    }
+	/* ------------------------------------------------------------ */
+	public boolean hasProgressed()
+	{
+		return false;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * Updates selection key. Adds operations types to the selection key as needed. No operations
-     * are removed as this is only done during dispatch. This method records the new key and
-     * schedules a call to doUpdateKey to do the keyChange
-     */
-    private void updateKey()
-    {
-        final boolean changed;
-        synchronized (this)
-        {
-            int current_ops=-1;
-            if (getChannel().isOpen())
-            {
-                boolean read_interest = _readBlocked || (_state<STATE_DISPATCHED && !_connection.isSuspended());
-                boolean write_interest= _writeBlocked || (_state<STATE_DISPATCHED && !_writable);
+	/* ------------------------------------------------------------ */
+	/**
+	 * Updates selection key. Adds operations types to the selection key as needed. No operations
+	 * are removed as this is only done during dispatch. This method records the new key and
+	 * schedules a call to doUpdateKey to do the keyChange
+	 */
+	private void updateKey()
+	{
+		final boolean changed;
+		synchronized (this)
+		{
+			int current_ops=-1;
+			if (getChannel().isOpen())
+			{
+				boolean read_interest = _readBlocked || (_state<STATE_DISPATCHED && !_connection.isSuspended());
+				boolean write_interest= _writeBlocked || (_state<STATE_DISPATCHED && !_writable);
 
-                _interestOps =
-                    ((!_socket.isInputShutdown() && read_interest ) ? SelectionKey.OP_READ  : 0)
-                |   ((!_socket.isOutputShutdown()&& write_interest) ? SelectionKey.OP_WRITE : 0);
-                try
-                {
-                    current_ops = ((_key!=null && _key.isValid())?_key.interestOps():-1);
-                }
-                catch(Exception e)
-                {
-                    _key=null;
-                    LOG.trace("",e);
-                }
-            }
-            changed=_interestOps!=current_ops;
-        }
+				_interestOps =
+					((!_socket.isInputShutdown() && read_interest ) ? SelectionKey.OP_READ  : 0)
+				|   ((!_socket.isOutputShutdown()&& write_interest) ? SelectionKey.OP_WRITE : 0);
+				try
+				{
+					current_ops = ((_key!=null && _key.isValid())?_key.interestOps():-1);
+				}
+				catch(Exception e)
+				{
+					_key=null;
+					LOG.trace("",e);
+				}
+			}
+			changed=_interestOps!=current_ops;
+		}
 
-        if(changed)
-        {
-            _selectSet.addChange(this);
-            _selectSet.wakeup();
-        }
-    }
+		if(changed)
+		{
+			_selectSet.addChange(this);
+			_selectSet.wakeup();
+		}
+	}
 
 
-    /* ------------------------------------------------------------ */
-    /**
-     * Synchronize the interestOps with the actual key. Call is scheduled by a call to updateKey
-     */
-    void doUpdateKey()
-    {
-        synchronized (this)
-        {
-            if (getChannel().isOpen())
-            {
-                if (_interestOps>0)
-                {
-                    if (_key==null || !_key.isValid())
-                    {
-                        SelectableChannel sc = (SelectableChannel)getChannel();
-                        if (sc.isRegistered())
-                        {
-                            updateKey();
-                        }
-                        else
-                        {
-                            try
-                            {
-                                _key=((SelectableChannel)getChannel()).register(_selectSet.getSelector(),_interestOps,this);
-                            }
-                            catch (Exception e)
-                            {
-                                LOG.trace("",e);
-                                if (_key!=null && _key.isValid())
-                                {
-                                    _key.cancel();
-                                }
+	/* ------------------------------------------------------------ */
+	/**
+	 * Synchronize the interestOps with the actual key. Call is scheduled by a call to updateKey
+	 */
+	void doUpdateKey()
+	{
+		synchronized (this)
+		{
+			if (getChannel().isOpen())
+			{
+				if (_interestOps>0)
+				{
+					if (_key==null || !_key.isValid())
+					{
+						SelectableChannel sc = (SelectableChannel)getChannel();
+						if (sc.isRegistered())
+						{
+							updateKey();
+						}
+						else
+						{
+							try
+							{
+								_key=((SelectableChannel)getChannel()).register(_selectSet.getSelector(),_interestOps,this);
+							}
+							catch (Exception e)
+							{
+								LOG.trace("",e);
+								if (_key!=null && _key.isValid())
+								{
+									_key.cancel();
+								}
 
-                                if (_open)
-                                {
-                                    _selectSet.destroyEndPoint(this);
-                                }
-                                _open=false;
-                                _key = null;
-                            }
-                        }
-                    }
-                    else
-                    {
-                        _key.interestOps(_interestOps);
-                    }
-                }
-                else
-                {
-                    if (_key!=null && _key.isValid())
-                        _key.interestOps(0);
-                    else
-                        _key=null;
-                }
-            }
-            else
-            {
-                if (_key!=null && _key.isValid())
-                    _key.cancel();
+								if (_open)
+								{
+									_selectSet.destroyEndPoint(this);
+								}
+								_open=false;
+								_key = null;
+							}
+						}
+					}
+					else
+					{
+						_key.interestOps(_interestOps);
+					}
+				}
+				else
+				{
+					if (_key!=null && _key.isValid())
+						_key.interestOps(0);
+					else
+						_key=null;
+				}
+			}
+			else
+			{
+				if (_key!=null && _key.isValid())
+					_key.cancel();
 
-                if (_open)
-                {
-                    _open=false;
-                    _selectSet.destroyEndPoint(this);
-                }
-                _key = null;
-            }
-        }
-    }
+				if (_open)
+				{
+					_open=false;
+					_selectSet.destroyEndPoint(this);
+				}
+				_key = null;
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /*
-     */
-    protected void handle()
-    {
-        boolean dispatched=true;
-        try
-        {
-            while(dispatched)
-            {
-                try
-                {
-                    while(true)
-                    {
-                        final AsyncConnection next = (AsyncConnection)_connection.handle();
-                        if (next!=_connection)
-                        {
-                            LOG.debug("{} replaced {}",next,_connection);
-                            Connection old=_connection;
-                            _connection=next;
-                            _manager.endPointUpgraded(this,old);
-                            continue;
-                        }
-                        break;
-                    }
-                }
-                catch (ClosedChannelException e)
-                {
-                    LOG.trace("",e);
-                }
-                catch (EofException e)
-                {
-                    LOG.debug("EOF", e);
-                    try{close();}
-                    catch(IOException e2){LOG.trace("",e2);}
-                }
-                catch (IOException e)
-                {
-                    LOG.warn(e.toString());
-                    try{close();}
-                    catch(IOException e2){LOG.trace("",e2);}
-                }
-                catch (Throwable e)
-                {
-                    LOG.warn("handle failed", e);
-                    try{close();}
-                    catch(IOException e2){LOG.trace("",e2);}
-                }
-                finally
-                {
-                    if (!_ishut && isInputShutdown() && isOpen())
-                    {
-                        _ishut=true;
-                        try
-                        {
-                            _connection.onInputShutdown();
-                        }
-                        catch(Throwable x)
-                        {
-                            LOG.warn("onInputShutdown failed", x);
-                            try{close();}
-                            catch(IOException e2){LOG.trace("",e2);}
-                        }
-                        finally
-                        {
-                            updateKey();
-                        }
-                    }
-                    dispatched=!undispatch();
-                }
-            }
-        }
-        finally
-        {
-            if (dispatched)
-            {
-                dispatched=!undispatch();
-                while (dispatched)
-                {
-                    LOG.warn("SCEP.run() finally DISPATCHED");
-                    dispatched=!undispatch();
-                }
-            }
-        }
-    }
+	/* ------------------------------------------------------------ */
+	/*
+	 */
+	protected void handle()
+	{
+		boolean dispatched=true;
+		try
+		{
+			while(dispatched)
+			{
+				try
+				{
+					while(true)
+					{
+						final AsyncConnection next = (AsyncConnection)_connection.handle();
+						if (next!=_connection)
+						{
+							LOG.debug("{} replaced {}",next,_connection);
+							Connection old=_connection;
+							_connection=next;
+							_manager.endPointUpgraded(this,old);
+							continue;
+						}
+						break;
+					}
+				}
+				catch (ClosedChannelException e)
+				{
+					LOG.trace("",e);
+				}
+				catch (EofException e)
+				{
+					LOG.debug("EOF", e);
+					try{close();}
+					catch(IOException e2){LOG.trace("",e2);}
+				}
+				catch (IOException e)
+				{
+					LOG.warn(e.toString());
+					try{close();}
+					catch(IOException e2){LOG.trace("",e2);}
+				}
+				catch (Throwable e)
+				{
+					LOG.warn("handle failed", e);
+					try{close();}
+					catch(IOException e2){LOG.trace("",e2);}
+				}
+				finally
+				{
+					if (!_ishut && isInputShutdown() && isOpen())
+					{
+						_ishut=true;
+						try
+						{
+							_connection.onInputShutdown();
+						}
+						catch(Throwable x)
+						{
+							LOG.warn("onInputShutdown failed", x);
+							try{close();}
+							catch(IOException e2){LOG.trace("",e2);}
+						}
+						finally
+						{
+							updateKey();
+						}
+					}
+					dispatched=!undispatch();
+				}
+			}
+		}
+		finally
+		{
+			if (dispatched)
+			{
+				dispatched=!undispatch();
+				while (dispatched)
+				{
+					LOG.warn("SCEP.run() finally DISPATCHED");
+					dispatched=!undispatch();
+				}
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /*
-     * @see org.eclipse.io.nio.ChannelEndPoint#close()
-     */
-    @Override
-    public void close() throws IOException
-    {
-        // On unix systems there is a JVM issue that if you cancel before closing, it can 
-        // cause the selector to block waiting for a channel to close and that channel can 
-        // block waiting for the remote end.  But on windows, if you don't cancel before a 
-        // close, then the selector can block anyway!
-        // https://bugs.eclipse.org/bugs/show_bug.cgi?id=357318
-        if (WORK_AROUND_JVM_BUG_6346658)
-        {
-            try
-            {
-                SelectionKey key = _key;
-                if (key!=null)
-                    key.cancel();
-            }
-            catch (Throwable e)
-            {
-                LOG.trace("",e);
-            }
-        }
+	/* ------------------------------------------------------------ */
+	/*
+	 * @see org.eclipse.io.nio.ChannelEndPoint#close()
+	 */
+	@Override
+	public void close() throws IOException
+	{
+		// On unix systems there is a JVM issue that if you cancel before closing, it can 
+		// cause the selector to block waiting for a channel to close and that channel can 
+		// block waiting for the remote end.  But on windows, if you don't cancel before a 
+		// close, then the selector can block anyway!
+		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=357318
+		if (WORK_AROUND_JVM_BUG_6346658)
+		{
+			try
+			{
+				SelectionKey key = _key;
+				if (key!=null)
+					key.cancel();
+			}
+			catch (Throwable e)
+			{
+				LOG.trace("",e);
+			}
+		}
 
-        try
-        {
-            super.close();
-        }
-        catch (IOException e)
-        {
-            LOG.trace("",e);
-        }
-        finally
-        {
-            updateKey();
-        }
-    }
+		try
+		{
+			super.close();
+		}
+		catch (IOException e)
+		{
+			LOG.trace("",e);
+		}
+		finally
+		{
+			updateKey();
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    @Override
-    public String toString()
-    {
-        // Do NOT use synchronized (this)
-        // because it's very easy to deadlock when debugging is enabled.
-        // We do a best effort to print the right toString() and that's it.
-        SelectionKey key = _key;
-        String keyString = "";
-        if (key != null)
-        {
-            if (key.isValid())
-            {
-                if (key.isReadable())
-                    keyString += "r";
-                if (key.isWritable())
-                    keyString += "w";
-            }
-            else
-            {
-                keyString += "!";
-            }
-        }
-        else
-        {
-            keyString += "-";
-        }
-        return String.format("SCEP@%x{l(%s)<->r(%s),s=%d,open=%b,ishut=%b,oshut=%b,rb=%b,wb=%b,w=%b,i=%d%s}-{%s}",
-                hashCode(),
-                _socket.getRemoteSocketAddress(),
-                _socket.getLocalSocketAddress(),
-                _state,
-                isOpen(),
-                isInputShutdown(),
-                isOutputShutdown(),
-                _readBlocked,
-                _writeBlocked,
-                _writable,
-                _interestOps,
-                keyString,
-                _connection);
-    }
+	/* ------------------------------------------------------------ */
+	@Override
+	public String toString()
+	{
+		// Do NOT use synchronized (this)
+		// because it's very easy to deadlock when debugging is enabled.
+		// We do a best effort to print the right toString() and that's it.
+		SelectionKey key = _key;
+		String keyString = "";
+		if (key != null)
+		{
+			if (key.isValid())
+			{
+				if (key.isReadable())
+					keyString += "r";
+				if (key.isWritable())
+					keyString += "w";
+			}
+			else
+			{
+				keyString += "!";
+			}
+		}
+		else
+		{
+			keyString += "-";
+		}
+		return String.format("SCEP@%x{l(%s)<->r(%s),s=%d,open=%b,ishut=%b,oshut=%b,rb=%b,wb=%b,w=%b,i=%d%s}-{%s}",
+				hashCode(),
+				_socket.getRemoteSocketAddress(),
+				_socket.getLocalSocketAddress(),
+				_state,
+				isOpen(),
+				isInputShutdown(),
+				isOutputShutdown(),
+				_readBlocked,
+				_writeBlocked,
+				_writable,
+				_interestOps,
+				keyString,
+				_connection);
+	}
 
-    /* ------------------------------------------------------------ */
-    public SelectSet getSelectSet()
-    {
-        return _selectSet;
-    }
+	/* ------------------------------------------------------------ */
+	public SelectSet getSelectSet()
+	{
+		return _selectSet;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * Don't set the SoTimeout
-     * @see org.eclipse.jetty.io.nio.ChannelEndPoint#setMaxIdleTime(int)
-     */
-    @Override
-    public void setMaxIdleTime(int timeMs) throws IOException
-    {
-        _maxIdleTime=timeMs;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * Don't set the SoTimeout
+	 * @see org.eclipse.jetty.io.nio.ChannelEndPoint#setMaxIdleTime(int)
+	 */
+	@Override
+	public void setMaxIdleTime(int timeMs) throws IOException
+	{
+		_maxIdleTime=timeMs;
+	}
 
 }
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/io/nio/SelectorManager.java
--- a/src/org/eclipse/jetty/io/nio/SelectorManager.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/io/nio/SelectorManager.java	Sun Oct 02 20:38:06 2016 -0600
@@ -58,977 +58,974 @@
  */
 public abstract class SelectorManager extends AbstractLifeCycle implements Dumpable
 {
-    public static final Logger LOG=LoggerFactory.getLogger("org.eclipse.jetty.io.nio");
+	public static final Logger LOG=LoggerFactory.getLogger("org.eclipse.jetty.io.nio");
 
-    private static final int __MONITOR_PERIOD=Integer.getInteger("org.eclipse.jetty.io.nio.MONITOR_PERIOD",1000).intValue();
-    private static final int __MAX_SELECTS=Integer.getInteger("org.eclipse.jetty.io.nio.MAX_SELECTS",100000).intValue();
-    private static final int __BUSY_PAUSE=Integer.getInteger("org.eclipse.jetty.io.nio.BUSY_PAUSE",50).intValue();
-    private static final int __IDLE_TICK=Integer.getInteger("org.eclipse.jetty.io.nio.IDLE_TICK",400).intValue();
+	private static final int __MONITOR_PERIOD=Integer.getInteger("org.eclipse.jetty.io.nio.MONITOR_PERIOD",1000).intValue();
+	private static final int __MAX_SELECTS=Integer.getInteger("org.eclipse.jetty.io.nio.MAX_SELECTS",100000).intValue();
+	private static final int __BUSY_PAUSE=Integer.getInteger("org.eclipse.jetty.io.nio.BUSY_PAUSE",50).intValue();
+	private static final int __IDLE_TICK=Integer.getInteger("org.eclipse.jetty.io.nio.IDLE_TICK",400).intValue();
 
-    private int _maxIdleTime;
-    private int _lowResourcesMaxIdleTime;
-    private long _lowResourcesConnections;
-    private SelectSet[] _selectSet;
-    private int _selectSets=1;
-    private volatile int _set=0;
-    private boolean _deferringInterestedOps0=true;
-    private int _selectorPriorityDelta=0;
+	private int _maxIdleTime;
+	private int _lowResourcesMaxIdleTime;
+	private long _lowResourcesConnections;
+	private SelectSet[] _selectSet;
+	private int _selectSets=1;
+	private volatile int _set=0;
+	private boolean _deferringInterestedOps0=true;
+	private int _selectorPriorityDelta=0;
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @param maxIdleTime The maximum period in milli seconds that a connection may be idle before it is closed.
-     * @see #setLowResourcesMaxIdleTime(long)
-     */
-    public void setMaxIdleTime(long maxIdleTime)
-    {
-        _maxIdleTime=(int)maxIdleTime;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @param maxIdleTime The maximum period in milli seconds that a connection may be idle before it is closed.
+	 * @see #setLowResourcesMaxIdleTime(long)
+	 */
+	public void setMaxIdleTime(long maxIdleTime)
+	{
+		_maxIdleTime=(int)maxIdleTime;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @param selectSets number of select sets to create
-     */
-    public void setSelectSets(int selectSets)
-    {
-        long lrc = _lowResourcesConnections * _selectSets;
-        _selectSets=selectSets;
-        _lowResourcesConnections=lrc/_selectSets;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @param selectSets number of select sets to create
+	 */
+	public void setSelectSets(int selectSets)
+	{
+		long lrc = _lowResourcesConnections * _selectSets;
+		_selectSets=selectSets;
+		_lowResourcesConnections=lrc/_selectSets;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @return the max idle time
-     */
-    public long getMaxIdleTime()
-    {
-        return _maxIdleTime;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @return the max idle time
+	 */
+	public long getMaxIdleTime()
+	{
+		return _maxIdleTime;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @return the number of select sets in use
-     */
-    public int getSelectSets()
-    {
-        return _selectSets;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @return the number of select sets in use
+	 */
+	public int getSelectSets()
+	{
+		return _selectSets;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @param i
-     * @return The select set
-     */
-    public SelectSet getSelectSet(int i)
-    {
-        return _selectSet[i];
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @param i
+	 * @return The select set
+	 */
+	public SelectSet getSelectSet(int i)
+	{
+		return _selectSet[i];
+	}
 
-    /* ------------------------------------------------------------ */
-    /** Register a channel
-     * @param channel
-     * @param att Attached Object
-     */
-    public void register(SocketChannel channel, Object att)
-    {
-        // The ++ increment here is not atomic, but it does not matter.
-        // so long as the value changes sometimes, then connections will
-        // be distributed over the available sets.
+	/* ------------------------------------------------------------ */
+	/** Register a channel
+	 * @param channel
+	 * @param att Attached Object
+	 */
+	public void register(SocketChannel channel, Object att)
+	{
+		// The ++ increment here is not atomic, but it does not matter.
+		// so long as the value changes sometimes, then connections will
+		// be distributed over the available sets.
 
-        int s=_set++;
-        if (s<0)
-            s=-s;
-        s=s%_selectSets;
-        SelectSet[] sets=_selectSet;
-        if (sets!=null)
-        {
-            SelectSet set=sets[s];
-            set.addChange(channel,att);
-            set.wakeup();
-        }
-    }
+		int s=_set++;
+		if (s<0)
+			s=-s;
+		s=s%_selectSets;
+		SelectSet[] sets=_selectSet;
+		if (sets!=null)
+		{
+			SelectSet set=sets[s];
+			set.addChange(channel,att);
+			set.wakeup();
+		}
+	}
 
 
-    /* ------------------------------------------------------------ */
-    /** Register a channel
-     * @param channel
-     */
-    public void register(SocketChannel channel)
-    {
-        // The ++ increment here is not atomic, but it does not matter.
-        // so long as the value changes sometimes, then connections will
-        // be distributed over the available sets.
+	/* ------------------------------------------------------------ */
+	/** Register a channel
+	 * @param channel
+	 */
+	public void register(SocketChannel channel)
+	{
+		// The ++ increment here is not atomic, but it does not matter.
+		// so long as the value changes sometimes, then connections will
+		// be distributed over the available sets.
 
-        int s=_set++;
-        if (s<0)
-            s=-s;
-        s=s%_selectSets;
-        SelectSet[] sets=_selectSet;
-        if (sets!=null)
-        {
-            SelectSet set=sets[s];
-            set.addChange(channel);
-            set.wakeup();
-        }
-    }
+		int s=_set++;
+		if (s<0)
+			s=-s;
+		s=s%_selectSets;
+		SelectSet[] sets=_selectSet;
+		if (sets!=null)
+		{
+			SelectSet set=sets[s];
+			set.addChange(channel);
+			set.wakeup();
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /** Register a {@link ServerSocketChannel}
-     * @param acceptChannel
-     */
-    public void register(ServerSocketChannel acceptChannel)
-    {
-        int s=_set++;
-        if (s<0)
-            s=-s;
-        s=s%_selectSets;
-        SelectSet set=_selectSet[s];
-        set.addChange(acceptChannel);
-        set.wakeup();
-    }
+	/* ------------------------------------------------------------ */
+	/** Register a {@link ServerSocketChannel}
+	 * @param acceptChannel
+	 */
+	public void register(ServerSocketChannel acceptChannel)
+	{
+		int s=_set++;
+		if (s<0)
+			s=-s;
+		s=s%_selectSets;
+		SelectSet set=_selectSet[s];
+		set.addChange(acceptChannel);
+		set.wakeup();
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @return delta The value to add to the selector thread priority.
-     */
-    public int getSelectorPriorityDelta()
-    {
-        return _selectorPriorityDelta;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @return delta The value to add to the selector thread priority.
+	 */
+	public int getSelectorPriorityDelta()
+	{
+		return _selectorPriorityDelta;
+	}
 
-    /* ------------------------------------------------------------ */
-    /** Set the selector thread priorty delta.
-     * @param delta The value to add to the selector thread priority.
-     */
-    public void setSelectorPriorityDelta(int delta)
-    {
-        _selectorPriorityDelta=delta;
-    }
+	/* ------------------------------------------------------------ */
+	/** Set the selector thread priorty delta.
+	 * @param delta The value to add to the selector thread priority.
+	 */
+	public void setSelectorPriorityDelta(int delta)
+	{
+		_selectorPriorityDelta=delta;
+	}
 
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @return the lowResourcesConnections
-     */
-    public long getLowResourcesConnections()
-    {
-        return _lowResourcesConnections*_selectSets;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @return the lowResourcesConnections
+	 */
+	public long getLowResourcesConnections()
+	{
+		return _lowResourcesConnections*_selectSets;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * Set the number of connections, which if exceeded places this manager in low resources state.
-     * This is not an exact measure as the connection count is averaged over the select sets.
-     * @param lowResourcesConnections the number of connections
-     * @see #setLowResourcesMaxIdleTime(long)
-     */
-    public void setLowResourcesConnections(long lowResourcesConnections)
-    {
-        _lowResourcesConnections=(lowResourcesConnections+_selectSets-1)/_selectSets;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * Set the number of connections, which if exceeded places this manager in low resources state.
+	 * This is not an exact measure as the connection count is averaged over the select sets.
+	 * @param lowResourcesConnections the number of connections
+	 * @see #setLowResourcesMaxIdleTime(long)
+	 */
+	public void setLowResourcesConnections(long lowResourcesConnections)
+	{
+		_lowResourcesConnections=(lowResourcesConnections+_selectSets-1)/_selectSets;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @return the lowResourcesMaxIdleTime
-     */
-    public long getLowResourcesMaxIdleTime()
-    {
-        return _lowResourcesMaxIdleTime;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @return the lowResourcesMaxIdleTime
+	 */
+	public long getLowResourcesMaxIdleTime()
+	{
+		return _lowResourcesMaxIdleTime;
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @param lowResourcesMaxIdleTime the period in ms that a connection is allowed to be idle when this SelectSet has more connections than {@link #getLowResourcesConnections()}
-     * @see #setMaxIdleTime(long)
-     */
-    public void setLowResourcesMaxIdleTime(long lowResourcesMaxIdleTime)
-    {
-        _lowResourcesMaxIdleTime=(int)lowResourcesMaxIdleTime;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @param lowResourcesMaxIdleTime the period in ms that a connection is allowed to be idle when this SelectSet has more connections than {@link #getLowResourcesConnections()}
+	 * @see #setMaxIdleTime(long)
+	 */
+	public void setLowResourcesMaxIdleTime(long lowResourcesMaxIdleTime)
+	{
+		_lowResourcesMaxIdleTime=(int)lowResourcesMaxIdleTime;
+	}
 
 
-    /* ------------------------------------------------------------------------------- */
-    public abstract boolean dispatch(Runnable task);
+	/* ------------------------------------------------------------------------------- */
+	public abstract void execute(Runnable task);
 
-    /* ------------------------------------------------------------ */
-    /* (non-Javadoc)
-     * @see org.eclipse.component.AbstractLifeCycle#doStart()
-     */
-    @Override
-    protected void doStart() throws Exception
-    {
-        _selectSet = new SelectSet[_selectSets];
-        for (int i=0;i<_selectSet.length;i++)
-            _selectSet[i]= new SelectSet(i);
+	/* ------------------------------------------------------------ */
+	/* (non-Javadoc)
+	 * @see org.eclipse.component.AbstractLifeCycle#doStart()
+	 */
+	@Override
+	protected void doStart() throws Exception
+	{
+		_selectSet = new SelectSet[_selectSets];
+		for (int i=0;i<_selectSet.length;i++)
+			_selectSet[i]= new SelectSet(i);
 
-        super.doStart();
+		super.doStart();
 
-        // start a thread to Select
-        for (int i=0;i<getSelectSets();i++)
-        {
-            final int id=i;
-            boolean selecting=dispatch(new Runnable()
-            {
-                public void run()
-                {
-                    String name=Thread.currentThread().getName();
-                    int priority=Thread.currentThread().getPriority();
-                    try
-                    {
-                        SelectSet[] sets=_selectSet;
-                        if (sets==null)
-                            return;
-                        SelectSet set=sets[id];
+		// start a thread to Select
+		for (int i=0;i<getSelectSets();i++)
+		{
+			final int id=i;
+			execute(new Runnable()
+			{
+				public void run()
+				{
+					String name=Thread.currentThread().getName();
+					int priority=Thread.currentThread().getPriority();
+					try
+					{
+						SelectSet[] sets=_selectSet;
+						if (sets==null)
+							return;
+						SelectSet set=sets[id];
 
-                        Thread.currentThread().setName(name+" Selector"+id);
-                        if (getSelectorPriorityDelta()!=0)
-                            Thread.currentThread().setPriority(Thread.currentThread().getPriority()+getSelectorPriorityDelta());
-                        LOG.debug("Starting {} on {}",Thread.currentThread(),this);
-                        while (isRunning())
-                        {
-                            try
-                            {
-                                set.doSelect();
-                            }
-                            catch(IOException e)
-                            {
-                                LOG.trace("",e);
-                            }
-                            catch(Exception e)
-                            {
-                                LOG.warn("",e);
-                            }
-                        }
-                    }
-                    finally
-                    {
-                        LOG.debug("Stopped {} on {}",Thread.currentThread(),this);
-                        Thread.currentThread().setName(name);
-                        if (getSelectorPriorityDelta()!=0)
-                            Thread.currentThread().setPriority(priority);
-                    }
-                }
+						Thread.currentThread().setName(name+" Selector"+id);
+						if (getSelectorPriorityDelta()!=0)
+							Thread.currentThread().setPriority(Thread.currentThread().getPriority()+getSelectorPriorityDelta());
+						LOG.debug("Starting {} on {}",Thread.currentThread(),this);
+						while (isRunning())
+						{
+							try
+							{
+								set.doSelect();
+							}
+							catch(IOException e)
+							{
+								LOG.trace("",e);
+							}
+							catch(Exception e)
+							{
+								LOG.warn("",e);
+							}
+						}
+					}
+					finally
+					{
+						LOG.debug("Stopped {} on {}",Thread.currentThread(),this);
+						Thread.currentThread().setName(name);
+						if (getSelectorPriorityDelta()!=0)
+							Thread.currentThread().setPriority(priority);
+					}
+				}
 
-            });
-
-            if (!selecting)
-                throw new IllegalStateException("!Selecting");
-        }
-    }
+			});
+		}
+	}
 
 
-    /* ------------------------------------------------------------------------------- */
-    @Override
-    protected void doStop() throws Exception
-    {
-        SelectSet[] sets= _selectSet;
-        _selectSet=null;
-        if (sets!=null)
-        {
-            for (SelectSet set : sets)
-            {
-                if (set!=null)
-                    set.stop();
-            }
-        }
-        super.doStop();
-    }
+	/* ------------------------------------------------------------------------------- */
+	@Override
+	protected void doStop() throws Exception
+	{
+		SelectSet[] sets= _selectSet;
+		_selectSet=null;
+		if (sets!=null)
+		{
+			for (SelectSet set : sets)
+			{
+				if (set!=null)
+					set.stop();
+			}
+		}
+		super.doStop();
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @param endpoint
-     */
-    protected abstract void endPointClosed(SelectChannelEndPoint endpoint);
+	/* ------------------------------------------------------------ */
+	/**
+	 * @param endpoint
+	 */
+	protected abstract void endPointClosed(SelectChannelEndPoint endpoint);
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @param endpoint
-     */
-    protected abstract void endPointOpened(SelectChannelEndPoint endpoint);
+	/* ------------------------------------------------------------ */
+	/**
+	 * @param endpoint
+	 */
+	protected abstract void endPointOpened(SelectChannelEndPoint endpoint);
 
-    /* ------------------------------------------------------------ */
-    protected abstract void endPointUpgraded(ConnectedEndPoint endpoint,Connection oldConnection);
+	/* ------------------------------------------------------------ */
+	protected abstract void endPointUpgraded(ConnectedEndPoint endpoint,Connection oldConnection);
 
-    /* ------------------------------------------------------------------------------- */
-    public abstract AsyncConnection newConnection(SocketChannel channel, AsyncEndPoint endpoint, Object attachment);
+	/* ------------------------------------------------------------------------------- */
+	public abstract AsyncConnection newConnection(SocketChannel channel, AsyncEndPoint endpoint, Object attachment);
 
-    /* ------------------------------------------------------------ */
-    /**
-     * Create a new end point
-     * @param channel
-     * @param selectSet
-     * @param sKey the selection key
-     * @return the new endpoint {@link SelectChannelEndPoint}
-     * @throws IOException
-     */
-    protected abstract SelectChannelEndPoint newEndPoint(SocketChannel channel, SelectorManager.SelectSet selectSet, SelectionKey sKey) throws IOException;
+	/* ------------------------------------------------------------ */
+	/**
+	 * Create a new end point
+	 * @param channel
+	 * @param selectSet
+	 * @param sKey the selection key
+	 * @return the new endpoint {@link SelectChannelEndPoint}
+	 * @throws IOException
+	 */
+	protected abstract SelectChannelEndPoint newEndPoint(SocketChannel channel, SelectorManager.SelectSet selectSet, SelectionKey sKey) throws IOException;
 
-    /* ------------------------------------------------------------------------------- */
-    protected void connectionFailed(SocketChannel channel,Throwable ex,Object attachment)
-    {
-        LOG.warn(ex+","+channel+","+attachment);
-        LOG.debug("",ex);
-    }
+	/* ------------------------------------------------------------------------------- */
+	protected void connectionFailed(SocketChannel channel,Throwable ex,Object attachment)
+	{
+		LOG.warn(ex+","+channel+","+attachment);
+		LOG.debug("",ex);
+	}
 
-    /* ------------------------------------------------------------ */
-    public String dump()
-    {
-        return AggregateLifeCycle.dump(this);
-    }
+	/* ------------------------------------------------------------ */
+	public String dump()
+	{
+		return AggregateLifeCycle.dump(this);
+	}
 
-    /* ------------------------------------------------------------ */
-    public void dump(Appendable out, String indent) throws IOException
-    {
-        AggregateLifeCycle.dumpObject(out,this);
-        AggregateLifeCycle.dump(out,indent,TypeUtil.asList(_selectSet));
-    }
+	/* ------------------------------------------------------------ */
+	public void dump(Appendable out, String indent) throws IOException
+	{
+		AggregateLifeCycle.dumpObject(out,this);
+		AggregateLifeCycle.dump(out,indent,TypeUtil.asList(_selectSet));
+	}
 
 
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    public class SelectSet implements Dumpable
-    {
-        private final int _setID;
-        private final Timeout _timeout;
+	/* ------------------------------------------------------------------------------- */
+	/* ------------------------------------------------------------------------------- */
+	/* ------------------------------------------------------------------------------- */
+	public class SelectSet implements Dumpable
+	{
+		private final int _setID;
+		private final Timeout _timeout;
 
-        private final ConcurrentLinkedQueue<Object> _changes = new ConcurrentLinkedQueue<Object>();
+		private final ConcurrentLinkedQueue<Object> _changes = new ConcurrentLinkedQueue<Object>();
 
-        private volatile Selector _selector;
+		private volatile Selector _selector;
 
-        private volatile Thread _selecting;
-        private int _busySelects;
-        private long _monitorNext;
-        private boolean _pausing;
-        private boolean _paused;
-        private volatile long _idleTick;
-        private ConcurrentMap<SelectChannelEndPoint,Object> _endPoints = new ConcurrentHashMap<SelectChannelEndPoint, Object>();
+		private volatile Thread _selecting;
+		private int _busySelects;
+		private long _monitorNext;
+		private boolean _pausing;
+		private boolean _paused;
+		private volatile long _idleTick;
+		private ConcurrentMap<SelectChannelEndPoint,Object> _endPoints = new ConcurrentHashMap<SelectChannelEndPoint, Object>();
 
-        /* ------------------------------------------------------------ */
-        SelectSet(int acceptorID) throws Exception
-        {
-            _setID=acceptorID;
+		/* ------------------------------------------------------------ */
+		SelectSet(int acceptorID) throws Exception
+		{
+			_setID=acceptorID;
 
-            _idleTick = System.currentTimeMillis();
-            _timeout = new Timeout(this);
-            _timeout.setDuration(0L);
+			_idleTick = System.currentTimeMillis();
+			_timeout = new Timeout(this);
+			_timeout.setDuration(0L);
 
-            // create a selector;
-            _selector = Selector.open();
-            _monitorNext=System.currentTimeMillis()+__MONITOR_PERIOD;
-        }
+			// create a selector;
+			_selector = Selector.open();
+			_monitorNext=System.currentTimeMillis()+__MONITOR_PERIOD;
+		}
 
-        /* ------------------------------------------------------------ */
-        public void addChange(Object change)
-        {
-            _changes.add(change);
-        }
+		/* ------------------------------------------------------------ */
+		public void addChange(Object change)
+		{
+			_changes.add(change);
+		}
 
-        /* ------------------------------------------------------------ */
-        public void addChange(SelectableChannel channel, Object att)
-        {
-            if (att==null)
-                addChange(channel);
-            else if (att instanceof EndPoint)
-                addChange(att);
-            else
-                addChange(new ChannelAndAttachment(channel,att));
-        }
+		/* ------------------------------------------------------------ */
+		public void addChange(SelectableChannel channel, Object att)
+		{
+			if (att==null)
+				addChange(channel);
+			else if (att instanceof EndPoint)
+				addChange(att);
+			else
+				addChange(new ChannelAndAttachment(channel,att));
+		}
 
-        /* ------------------------------------------------------------ */
-        /**
-         * Select and dispatch tasks found from changes and the selector.
-         *
-         * @throws IOException
-         */
-        public void doSelect() throws IOException
-        {
-            try
-            {
-                _selecting=Thread.currentThread();
-                final Selector selector=_selector;
-                // Stopped concurrently ?
-                if (selector == null)
-                    return;
+		/* ------------------------------------------------------------ */
+		/**
+		 * Select and dispatch tasks found from changes and the selector.
+		 *
+		 * @throws IOException
+		 */
+		public void doSelect() throws IOException
+		{
+			try
+			{
+				_selecting=Thread.currentThread();
+				final Selector selector=_selector;
+				// Stopped concurrently ?
+				if (selector == null)
+					return;
 
-                // Make any key changes required
-                Object change;
-                int changes=_changes.size();
-                while (changes-->0 && (change=_changes.poll())!=null)
-                {
-                    Channel ch=null;
-                    SelectionKey key=null;
+				// Make any key changes required
+				Object change;
+				int changes=_changes.size();
+				while (changes-->0 && (change=_changes.poll())!=null)
+				{
+					Channel ch=null;
+					SelectionKey key=null;
 
-                    try
-                    {
-                        if (change instanceof EndPoint)
-                        {
-                            // Update the operations for a key.
-                            SelectChannelEndPoint endpoint = (SelectChannelEndPoint)change;
-                            ch=endpoint.getChannel();
-                            endpoint.doUpdateKey();
-                        }
-                        else if (change instanceof ChannelAndAttachment)
-                        {
-                            // finish accepting/connecting this connection
-                            final ChannelAndAttachment asc = (ChannelAndAttachment)change;
-                            final SelectableChannel channel=asc._channel;
-                            ch=channel;
-                            final Object att = asc._attachment;
+					try
+					{
+						if (change instanceof EndPoint)
+						{
+							// Update the operations for a key.
+							SelectChannelEndPoint endpoint = (SelectChannelEndPoint)change;
+							ch=endpoint.getChannel();
+							endpoint.doUpdateKey();
+						}
+						else if (change instanceof ChannelAndAttachment)
+						{
+							// finish accepting/connecting this connection
+							final ChannelAndAttachment asc = (ChannelAndAttachment)change;
+							final SelectableChannel channel=asc._channel;
+							ch=channel;
+							final Object att = asc._attachment;
 
-                            if ((channel instanceof SocketChannel) && ((SocketChannel)channel).isConnected())
-                            {
-                                key = channel.register(selector,SelectionKey.OP_READ,att);
-                                SelectChannelEndPoint endpoint = createEndPoint((SocketChannel)channel,key);
-                                key.attach(endpoint);
-                                endpoint.schedule();
-                            }
-                            else if (channel.isOpen())
-                            {
-                                key = channel.register(selector,SelectionKey.OP_CONNECT,att);
-                            }
-                        }
-                        else if (change instanceof SocketChannel)
-                        {
-                            // Newly registered channel
-                            final SocketChannel channel=(SocketChannel)change;
-                            ch=channel;
-                            key = channel.register(selector,SelectionKey.OP_READ,null);
-                            SelectChannelEndPoint endpoint = createEndPoint(channel,key);
-                            key.attach(endpoint);
-                            endpoint.schedule();
-                        }
-                        else if (change instanceof ChangeTask)
-                        {
-                            ((Runnable)change).run();
-                        }
-                        else if (change instanceof Runnable)
-                        {
-                            dispatch((Runnable)change);
-                        }
-                        else
-                            throw new IllegalArgumentException(change.toString());
-                    }
-                    catch (CancelledKeyException e)
-                    {
-                        LOG.trace("",e);
-                    }
-                    catch (Throwable e)
-                    {
-                        if (isRunning())
-                            LOG.warn("",e);
-                        else
-                            LOG.debug("",e);
+							if ((channel instanceof SocketChannel) && ((SocketChannel)channel).isConnected())
+							{
+								key = channel.register(selector,SelectionKey.OP_READ,att);
+								SelectChannelEndPoint endpoint = createEndPoint((SocketChannel)channel,key);
+								key.attach(endpoint);
+								endpoint.schedule();
+							}
+							else if (channel.isOpen())
+							{
+								key = channel.register(selector,SelectionKey.OP_CONNECT,att);
+							}
+						}
+						else if (change instanceof SocketChannel)
+						{
+							// Newly registered channel
+							final SocketChannel channel=(SocketChannel)change;
+							ch=channel;
+							key = channel.register(selector,SelectionKey.OP_READ,null);
+							SelectChannelEndPoint endpoint = createEndPoint(channel,key);
+							key.attach(endpoint);
+							endpoint.schedule();
+						}
+						else if (change instanceof ChangeTask)
+						{
+							((Runnable)change).run();
+						}
+						else if (change instanceof Runnable)
+						{
+							execute((Runnable)change);
+						}
+						else
+							throw new IllegalArgumentException(change.toString());
+					}
+					catch (CancelledKeyException e)
+					{
+						LOG.trace("",e);
+					}
+					catch (Throwable e)
+					{
+						if (isRunning())
+							LOG.warn("",e);
+						else
+							LOG.debug("",e);
 
-                        try
-                        {
-                            if (ch!=null)
-                                ch.close();
-                        }
-                        catch(IOException e2)
-                        {
-                            LOG.debug("",e2);
-                        }
-                    }
-                }
+						try
+						{
+							if (ch!=null)
+								ch.close();
+						}
+						catch(IOException e2)
+						{
+							LOG.debug("",e2);
+						}
+					}
+				}
 
 
-                // Do and instant select to see if any connections can be handled.
-                int selected=selector.selectNow();
+				// Do and instant select to see if any connections can be handled.
+				int selected=selector.selectNow();
 
-                long now=System.currentTimeMillis();
+				long now=System.currentTimeMillis();
 
-                // if no immediate things to do
-                if (selected==0 && selector.selectedKeys().isEmpty())
-                {
-                    // If we are in pausing mode
-                    if (_pausing)
-                    {
-                        try
-                        {
-                            Thread.sleep(__BUSY_PAUSE); // pause to reduce impact of  busy loop
-                        }
-                        catch(InterruptedException e)
-                        {
-                            LOG.trace("",e);
-                        }
-                        now=System.currentTimeMillis();
-                    }
+				// if no immediate things to do
+				if (selected==0 && selector.selectedKeys().isEmpty())
+				{
+					// If we are in pausing mode
+					if (_pausing)
+					{
+						try
+						{
+							Thread.sleep(__BUSY_PAUSE); // pause to reduce impact of  busy loop
+						}
+						catch(InterruptedException e)
+						{
+							LOG.trace("",e);
+						}
+						now=System.currentTimeMillis();
+					}
 
-                    // workout how long to wait in select
-                    _timeout.setNow(now);
-                    long to_next_timeout=_timeout.getTimeToNext();
+					// workout how long to wait in select
+					_timeout.setNow(now);
+					long to_next_timeout=_timeout.getTimeToNext();
 
-                    long wait = _changes.size()==0?__IDLE_TICK:0L;
-                    if (wait > 0 && to_next_timeout >= 0 && wait > to_next_timeout)
-                        wait = to_next_timeout;
+					long wait = _changes.size()==0?__IDLE_TICK:0L;
+					if (wait > 0 && to_next_timeout >= 0 && wait > to_next_timeout)
+						wait = to_next_timeout;
 
-                    // If we should wait with a select
-                    if (wait>0)
-                    {
-                        long before=now;
-                        selector.select(wait);
-                        now = System.currentTimeMillis();
-                        _timeout.setNow(now);
+					// If we should wait with a select
+					if (wait>0)
+					{
+						long before=now;
+						selector.select(wait);
+						now = System.currentTimeMillis();
+						_timeout.setNow(now);
 
-                        // If we are monitoring for busy selector
-                        // and this select did not wait more than 1ms
-                        if (__MONITOR_PERIOD>0 && now-before <=1)
-                        {
-                            // count this as a busy select and if there have been too many this monitor cycle
-                            if (++_busySelects>__MAX_SELECTS)
-                            {
-                                // Start injecting pauses
-                                _pausing=true;
+						// If we are monitoring for busy selector
+						// and this select did not wait more than 1ms
+						if (__MONITOR_PERIOD>0 && now-before <=1)
+						{
+							// count this as a busy select and if there have been too many this monitor cycle
+							if (++_busySelects>__MAX_SELECTS)
+							{
+								// Start injecting pauses
+								_pausing=true;
 
-                                // if this is the first pause
-                                if (!_paused)
-                                {
-                                    // Log and dump some status
-                                    _paused=true;
-                                    LOG.warn("Selector {} is too busy, pausing!",this);
-                                }
-                            }
-                        }
-                    }
-                }
+								// if this is the first pause
+								if (!_paused)
+								{
+									// Log and dump some status
+									_paused=true;
+									LOG.warn("Selector {} is too busy, pausing!",this);
+								}
+							}
+						}
+					}
+				}
 
-                // have we been destroyed while sleeping
-                if (_selector==null || !selector.isOpen())
-                    return;
+				// have we been destroyed while sleeping
+				if (_selector==null || !selector.isOpen())
+					return;
 
-                // Look for things to do
-                for (SelectionKey key: selector.selectedKeys())
-                {
-                    SocketChannel channel=null;
+				// Look for things to do
+				for (SelectionKey key: selector.selectedKeys())
+				{
+					SocketChannel channel=null;
 
-                    try
-                    {
-                        if (!key.isValid())
-                        {
-                            key.cancel();
-                            SelectChannelEndPoint endpoint = (SelectChannelEndPoint)key.attachment();
-                            if (endpoint != null)
-                                endpoint.doUpdateKey();
-                            continue;
-                        }
+					try
+					{
+						if (!key.isValid())
+						{
+							key.cancel();
+							SelectChannelEndPoint endpoint = (SelectChannelEndPoint)key.attachment();
+							if (endpoint != null)
+								endpoint.doUpdateKey();
+							continue;
+						}
 
-                        Object att = key.attachment();
-                        if (att instanceof SelectChannelEndPoint)
-                        {
-                            if (key.isReadable()||key.isWritable())
-                                ((SelectChannelEndPoint)att).schedule();
-                        }
-                        else if (key.isConnectable())
-                        {
-                            // Complete a connection of a registered channel
-                            channel = (SocketChannel)key.channel();
-                            boolean connected=false;
-                            try
-                            {
-                                connected=channel.finishConnect();
-                            }
-                            catch(Exception e)
-                            {
-                                connectionFailed(channel,e,att);
-                            }
-                            finally
-                            {
-                                if (connected)
-                                {
-                                    key.interestOps(SelectionKey.OP_READ);
-                                    SelectChannelEndPoint endpoint = createEndPoint(channel,key);
-                                    key.attach(endpoint);
-                                    endpoint.schedule();
-                                }
-                                else
-                                {
-                                    key.cancel();
-                                    channel.close();
-                                }
-                            }
-                        }
-                        else
-                        {
-                            // Wrap readable registered channel in an endpoint
-                            channel = (SocketChannel)key.channel();
-                            SelectChannelEndPoint endpoint = createEndPoint(channel,key);
-                            key.attach(endpoint);
-                            if (key.isReadable())
-                                endpoint.schedule();
-                        }
-                        key = null;
-                    }
-                    catch (CancelledKeyException e)
-                    {
-                        LOG.trace("",e);
-                    }
-                    catch (Exception e)
-                    {
-                        if (isRunning())
-                            LOG.warn("",e);
-                        else
-                            LOG.trace("",e);
+						Object att = key.attachment();
+						if (att instanceof SelectChannelEndPoint)
+						{
+							if (key.isReadable()||key.isWritable())
+								((SelectChannelEndPoint)att).schedule();
+						}
+						else if (key.isConnectable())
+						{
+							// Complete a connection of a registered channel
+							channel = (SocketChannel)key.channel();
+							boolean connected=false;
+							try
+							{
+								connected=channel.finishConnect();
+							}
+							catch(Exception e)
+							{
+								connectionFailed(channel,e,att);
+							}
+							finally
+							{
+								if (connected)
+								{
+									key.interestOps(SelectionKey.OP_READ);
+									SelectChannelEndPoint endpoint = createEndPoint(channel,key);
+									key.attach(endpoint);
+									endpoint.schedule();
+								}
+								else
+								{
+									key.cancel();
+									channel.close();
+								}
+							}
+						}
+						else
+						{
+							// Wrap readable registered channel in an endpoint
+							channel = (SocketChannel)key.channel();
+							SelectChannelEndPoint endpoint = createEndPoint(channel,key);
+							key.attach(endpoint);
+							if (key.isReadable())
+								endpoint.schedule();
+						}
+						key = null;
+					}
+					catch (CancelledKeyException e)
+					{
+						LOG.trace("",e);
+					}
+					catch (Exception e)
+					{
+						if (isRunning())
+							LOG.warn("",e);
+						else
+							LOG.trace("",e);
 
-                        try
-                        {
-                            if (channel!=null)
-                                channel.close();
-                        }
-                        catch(IOException e2)
-                        {
-                            LOG.debug("",e2);
-                        }
+						try
+						{
+							if (channel!=null)
+								channel.close();
+						}
+						catch(IOException e2)
+						{
+							LOG.debug("",e2);
+						}
 
-                        if (key != null && !(key.channel() instanceof ServerSocketChannel) && key.isValid())
-                            key.cancel();
-                    }
-                }
+						if (key != null && !(key.channel() instanceof ServerSocketChannel) && key.isValid())
+							key.cancel();
+					}
+				}
 
-                // Everything always handled
-                selector.selectedKeys().clear();
+				// Everything always handled
+				selector.selectedKeys().clear();
 
-                now=System.currentTimeMillis();
-                _timeout.setNow(now);
-                Task task = _timeout.expired();
-                while (task!=null)
-                {
-                    if (task instanceof Runnable)
-                        dispatch((Runnable)task);
-                    task = _timeout.expired();
-                }
+				now=System.currentTimeMillis();
+				_timeout.setNow(now);
+				Task task = _timeout.expired();
+				while (task!=null)
+				{
+					if (task instanceof Runnable)
+						execute((Runnable)task);
+					task = _timeout.expired();
+				}
 
-                // Idle tick
-                if (now-_idleTick>__IDLE_TICK)
-                {
-                    _idleTick=now;
+				// Idle tick
+				if (now-_idleTick>__IDLE_TICK)
+				{
+					_idleTick=now;
 
-                    final long idle_now=((_lowResourcesConnections>0 && selector.keys().size()>_lowResourcesConnections))
-                        ?(now+_maxIdleTime-_lowResourcesMaxIdleTime)
-                        :now;
+					final long idle_now=((_lowResourcesConnections>0 && selector.keys().size()>_lowResourcesConnections))
+						?(now+_maxIdleTime-_lowResourcesMaxIdleTime)
+						:now;
 
-                    dispatch(new Runnable()
-                    {
-                        public void run()
-                        {
-                            for (SelectChannelEndPoint endp:_endPoints.keySet())
-                            {
-                                endp.checkIdleTimestamp(idle_now);
-                            }
-                        }
-                        public String toString() {return "Idle-"+super.toString();}
-                    });
+					execute(new Runnable()
+					{
+						public void run()
+						{
+							for (SelectChannelEndPoint endp:_endPoints.keySet())
+							{
+								endp.checkIdleTimestamp(idle_now);
+							}
+						}
+						public String toString() {return "Idle-"+super.toString();}
+					});
 
-                }
+				}
 
-                // Reset busy select monitor counts
-                if (__MONITOR_PERIOD>0 && now>_monitorNext)
-                {
-                    _busySelects=0;
-                    _pausing=false;
-                    _monitorNext=now+__MONITOR_PERIOD;
+				// Reset busy select monitor counts
+				if (__MONITOR_PERIOD>0 && now>_monitorNext)
+				{
+					_busySelects=0;
+					_pausing=false;
+					_monitorNext=now+__MONITOR_PERIOD;
 
-                }
-            }
-            catch (ClosedSelectorException e)
-            {
-                if (isRunning())
-                    LOG.warn("",e);
-                else
-                    LOG.trace("",e);
-            }
-            catch (CancelledKeyException e)
-            {
-                LOG.trace("",e);
-            }
-            finally
-            {
-                _selecting=null;
-            }
-        }
+				}
+			}
+			catch (ClosedSelectorException e)
+			{
+				if (isRunning())
+					LOG.warn("",e);
+				else
+					LOG.trace("",e);
+			}
+			catch (CancelledKeyException e)
+			{
+				LOG.trace("",e);
+			}
+			finally
+			{
+				_selecting=null;
+			}
+		}
 
 
-        /* ------------------------------------------------------------ */
-        private void renewSelector()
-        {
-            try
-            {
-                synchronized (this)
-                {
-                    Selector selector=_selector;
-                    if (selector==null)
-                        return;
-                    final Selector new_selector = Selector.open();
-                    for (SelectionKey k: selector.keys())
-                    {
-                        if (!k.isValid() || k.interestOps()==0)
-                            continue;
+		/* ------------------------------------------------------------ */
+		private void renewSelector()
+		{
+			try
+			{
+				synchronized (this)
+				{
+					Selector selector=_selector;
+					if (selector==null)
+						return;
+					final Selector new_selector = Selector.open();
+					for (SelectionKey k: selector.keys())
+					{
+						if (!k.isValid() || k.interestOps()==0)
+							continue;
 
-                        final SelectableChannel channel = k.channel();
-                        final Object attachment = k.attachment();
+						final SelectableChannel channel = k.channel();
+						final Object attachment = k.attachment();
 
-                        if (attachment==null)
-                            addChange(channel);
-                        else
-                            addChange(channel,attachment);
-                    }
-                    _selector.close();
-                    _selector=new_selector;
-                }
-            }
-            catch(IOException e)
-            {
-                throw new RuntimeException("recreating selector",e);
-            }
-        }
+						if (attachment==null)
+							addChange(channel);
+						else
+							addChange(channel,attachment);
+					}
+					_selector.close();
+					_selector=new_selector;
+				}
+			}
+			catch(IOException e)
+			{
+				throw new RuntimeException("recreating selector",e);
+			}
+		}
 
-        /* ------------------------------------------------------------ */
-        public SelectorManager getManager()
-        {
-            return SelectorManager.this;
-        }
+		/* ------------------------------------------------------------ */
+		public SelectorManager getManager()
+		{
+			return SelectorManager.this;
+		}
 
-        /* ------------------------------------------------------------ */
-        public long getNow()
-        {
-            return _timeout.getNow();
-        }
+		/* ------------------------------------------------------------ */
+		public long getNow()
+		{
+			return _timeout.getNow();
+		}
 
-        /* ------------------------------------------------------------ */
-        /**
-         * @param task The task to timeout. If it implements Runnable, then
-         * expired will be called from a dispatched thread.
-         *
-         * @param timeoutMs
-         */
-        public void scheduleTimeout(Timeout.Task task, long timeoutMs)
-        {
-            if (!(task instanceof Runnable))
-                throw new IllegalArgumentException("!Runnable");
-            _timeout.schedule(task, timeoutMs);
-        }
+		/* ------------------------------------------------------------ */
+		/**
+		 * @param task The task to timeout. If it implements Runnable, then
+		 * expired will be called from a dispatched thread.
+		 *
+		 * @param timeoutMs
+		 */
+		public void scheduleTimeout(Timeout.Task task, long timeoutMs)
+		{
+			if (!(task instanceof Runnable))
+				throw new IllegalArgumentException("!Runnable");
+			_timeout.schedule(task, timeoutMs);
+		}
 
-        /* ------------------------------------------------------------ */
-        public void cancelTimeout(Timeout.Task task)
-        {
-            task.cancel();
-        }
+		/* ------------------------------------------------------------ */
+		public void cancelTimeout(Timeout.Task task)
+		{
+			task.cancel();
+		}
 
-        /* ------------------------------------------------------------ */
-        public void wakeup()
-        {
-            try
-            {
-                Selector selector = _selector;
-                if (selector!=null)
-                    selector.wakeup();
-            }
-            catch(Exception e)
-            {
-                addChange(new ChangeTask()
-                {
-                    public void run()
-                    {
-                        renewSelector();
-                    }
-                });
+		/* ------------------------------------------------------------ */
+		public void wakeup()
+		{
+			try
+			{
+				Selector selector = _selector;
+				if (selector!=null)
+					selector.wakeup();
+			}
+			catch(Exception e)
+			{
+				addChange(new ChangeTask()
+				{
+					public void run()
+					{
+						renewSelector();
+					}
+				});
 
-                renewSelector();
-            }
-        }
+				renewSelector();
+			}
+		}
 
-        /* ------------------------------------------------------------ */
-        private SelectChannelEndPoint createEndPoint(SocketChannel channel, SelectionKey sKey) throws IOException
-        {
-            SelectChannelEndPoint endp = newEndPoint(channel,this,sKey);
-            LOG.debug("created {}",endp);
-            endPointOpened(endp);
-            _endPoints.put(endp,this);
-            return endp;
-        }
+		/* ------------------------------------------------------------ */
+		private SelectChannelEndPoint createEndPoint(SocketChannel channel, SelectionKey sKey) throws IOException
+		{
+			SelectChannelEndPoint endp = newEndPoint(channel,this,sKey);
+			LOG.debug("created {}",endp);
+			endPointOpened(endp);
+			_endPoints.put(endp,this);
+			return endp;
+		}
 
-        /* ------------------------------------------------------------ */
-        public void destroyEndPoint(SelectChannelEndPoint endp)
-        {
-            LOG.debug("destroyEndPoint {}",endp);
-            _endPoints.remove(endp);
-            endPointClosed(endp);
-        }
+		/* ------------------------------------------------------------ */
+		public void destroyEndPoint(SelectChannelEndPoint endp)
+		{
+			LOG.debug("destroyEndPoint {}",endp);
+			_endPoints.remove(endp);
+			endPointClosed(endp);
+		}
 
-        /* ------------------------------------------------------------ */
-        Selector getSelector()
-        {
-            return _selector;
-        }
+		/* ------------------------------------------------------------ */
+		Selector getSelector()
+		{
+			return _selector;
+		}
 
-        /* ------------------------------------------------------------ */
-        void stop() throws Exception
-        {
-            // Spin for a while waiting for selector to complete
-            // to avoid unneccessary closed channel exceptions
-            try
-            {
-                for (int i=0;i<100 && _selecting!=null;i++)
-                {
-                    wakeup();
-                    Thread.sleep(10);
-                }
-            }
-            catch(Exception e)
-            {
-                LOG.trace("",e);
-            }
+		/* ------------------------------------------------------------ */
+		void stop() throws Exception
+		{
+			// Spin for a while waiting for selector to complete
+			// to avoid unneccessary closed channel exceptions
+			try
+			{
+				for (int i=0;i<100 && _selecting!=null;i++)
+				{
+					wakeup();
+					Thread.sleep(10);
+				}
+			}
+			catch(Exception e)
+			{
+				LOG.trace("",e);
+			}
 
-            // close endpoints and selector
-            synchronized (this)
-            {
-                Selector selector=_selector;
-                for (SelectionKey key:selector.keys())
-                {
-                    if (key==null)
-                        continue;
-                    Object att=key.attachment();
-                    if (att instanceof EndPoint)
-                    {
-                        EndPoint endpoint = (EndPoint)att;
-                        try
-                        {
-                            endpoint.close();
-                        }
-                        catch(IOException e)
-                        {
-                            LOG.trace("",e);
-                        }
-                    }
-                }
+			// close endpoints and selector
+			synchronized (this)
+			{
+				Selector selector=_selector;
+				for (SelectionKey key:selector.keys())
+				{
+					if (key==null)
+						continue;
+					Object att=key.attachment();
+					if (att instanceof EndPoint)
+					{
+						EndPoint endpoint = (EndPoint)att;
+						try
+						{
+							endpoint.close();
+						}
+						catch(IOException e)
+						{
+							LOG.trace("",e);
+						}
+					}
+				}
 
 
-                _timeout.cancelAll();
-                try
-                {
-                    selector=_selector;
-                    if (selector != null)
-                        selector.close();
-                }
-                catch (IOException e)
-                {
-                    LOG.trace("",e);
-                }
-                _selector=null;
-            }
-        }
+				_timeout.cancelAll();
+				try
+				{
+					selector=_selector;
+					if (selector != null)
+						selector.close();
+				}
+				catch (IOException e)
+				{
+					LOG.trace("",e);
+				}
+				_selector=null;
+			}
+		}
 
-        /* ------------------------------------------------------------ */
-        public String dump()
-        {
-            return AggregateLifeCycle.dump(this);
-        }
+		/* ------------------------------------------------------------ */
+		public String dump()
+		{
+			return AggregateLifeCycle.dump(this);
+		}
 
-        /* ------------------------------------------------------------ */
-        public void dump(Appendable out, String indent) throws IOException
-        {
-            out.append(String.valueOf(this)).append(" id=").append(String.valueOf(_setID)).append("\n");
+		/* ------------------------------------------------------------ */
+		public void dump(Appendable out, String indent) throws IOException
+		{
+			out.append(String.valueOf(this)).append(" id=").append(String.valueOf(_setID)).append("\n");
 
-            Thread selecting = _selecting;
+			Thread selecting = _selecting;
 
-            Object where = "not selecting";
-            StackTraceElement[] trace =selecting==null?null:selecting.getStackTrace();
-            if (trace!=null)
-            {
-                for (StackTraceElement t:trace)
-                    if (t.getClassName().startsWith("org.eclipse.jetty."))
-                    {
-                        where=t;
-                        break;
-                    }
-            }
+			Object where = "not selecting";
+			StackTraceElement[] trace =selecting==null?null:selecting.getStackTrace();
+			if (trace!=null)
+			{
+				for (StackTraceElement t:trace)
+					if (t.getClassName().startsWith("org.eclipse.jetty."))
+					{
+						where=t;
+						break;
+					}
+			}
 
-            Selector selector=_selector;
-            if (selector!=null)
-            {
-                final ArrayList<Object> dump = new ArrayList<Object>(selector.keys().size()*2);
-                dump.add(where);
+			Selector selector=_selector;
+			if (selector!=null)
+			{
+				final ArrayList<Object> dump = new ArrayList<Object>(selector.keys().size()*2);
+				dump.add(where);
 
-                final CountDownLatch latch = new CountDownLatch(1);
+				final CountDownLatch latch = new CountDownLatch(1);
 
-                addChange(new ChangeTask()
-                {
-                    public void run()
-                    {
-                        dumpKeyState(dump);
-                        latch.countDown();
-                    }
-                });
+				addChange(new ChangeTask()
+				{
+					public void run()
+					{
+						dumpKeyState(dump);
+						latch.countDown();
+					}
+				});
 
-                try
-                {
-                    latch.await(5,TimeUnit.SECONDS);
-                }
-                catch(InterruptedException e)
-                {
-                    LOG.trace("",e);
-                }
+				try
+				{
+					latch.await(5,TimeUnit.SECONDS);
+				}
+				catch(InterruptedException e)
+				{
+					LOG.trace("",e);
+				}
 
-                AggregateLifeCycle.dump(out,indent,dump);
-            }
-        }
+				AggregateLifeCycle.dump(out,indent,dump);
+			}
+		}
 
-        /* ------------------------------------------------------------ */
-        public void dumpKeyState(List<Object> dumpto)
-        {
-            Selector selector=_selector;
-            Set<SelectionKey> keys = selector.keys();
-            dumpto.add(selector + " keys=" + keys.size());
-            for (SelectionKey key: keys)
-            {
-                if (key.isValid())
-                    dumpto.add(key.attachment()+" iOps="+key.interestOps()+" rOps="+key.readyOps());
-                else
-                    dumpto.add(key.attachment()+" iOps=-1 rOps=-1");
-            }
-        }
+		/* ------------------------------------------------------------ */
+		public void dumpKeyState(List<Object> dumpto)
+		{
+			Selector selector=_selector;
+			Set<SelectionKey> keys = selector.keys();
+			dumpto.add(selector + " keys=" + keys.size());
+			for (SelectionKey key: keys)
+			{
+				if (key.isValid())
+					dumpto.add(key.attachment()+" iOps="+key.interestOps()+" rOps="+key.readyOps());
+				else
+					dumpto.add(key.attachment()+" iOps=-1 rOps=-1");
+			}
+		}
 
-        /* ------------------------------------------------------------ */
-        public String toString()
-        {
-            Selector selector=_selector;
-            return String.format("%s keys=%d selected=%d",
-                    super.toString(),
-                    selector != null && selector.isOpen() ? selector.keys().size() : -1,
-                    selector != null && selector.isOpen() ? selector.selectedKeys().size() : -1);
-        }
-    }
+		/* ------------------------------------------------------------ */
+		public String toString()
+		{
+			Selector selector=_selector;
+			return String.format("%s keys=%d selected=%d",
+					super.toString(),
+					selector != null && selector.isOpen() ? selector.keys().size() : -1,
+					selector != null && selector.isOpen() ? selector.selectedKeys().size() : -1);
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    private static class ChannelAndAttachment
-    {
-        final SelectableChannel _channel;
-        final Object _attachment;
+	/* ------------------------------------------------------------ */
+	private static class ChannelAndAttachment
+	{
+		final SelectableChannel _channel;
+		final Object _attachment;
 
-        public ChannelAndAttachment(SelectableChannel channel, Object attachment)
-        {
-            super();
-            _channel = channel;
-            _attachment = attachment;
-        }
-    }
+		public ChannelAndAttachment(SelectableChannel channel, Object attachment)
+		{
+			super();
+			_channel = channel;
+			_attachment = attachment;
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public boolean isDeferringInterestedOps0()
-    {
-        return _deferringInterestedOps0;
-    }
+	/* ------------------------------------------------------------ */
+	public boolean isDeferringInterestedOps0()
+	{
+		return _deferringInterestedOps0;
+	}
 
-    /* ------------------------------------------------------------ */
-    public void setDeferringInterestedOps0(boolean deferringInterestedOps0)
-    {
-        _deferringInterestedOps0 = deferringInterestedOps0;
-    }
+	/* ------------------------------------------------------------ */
+	public void setDeferringInterestedOps0(boolean deferringInterestedOps0)
+	{
+		_deferringInterestedOps0 = deferringInterestedOps0;
+	}
 
 
-    /* ------------------------------------------------------------ */
-    /* ------------------------------------------------------------ */
-    /* ------------------------------------------------------------ */
-    private interface ChangeTask extends Runnable
-    {}
+	/* ------------------------------------------------------------ */
+	/* ------------------------------------------------------------ */
+	/* ------------------------------------------------------------ */
+	private interface ChangeTask extends Runnable
+	{}
 
 }
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/AbstractConnector.java
--- a/src/org/eclipse/jetty/server/AbstractConnector.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/AbstractConnector.java	Sun Oct 02 20:38:06 2016 -0600
@@ -22,6 +22,7 @@
 import java.net.InetAddress;
 import java.net.Socket;
 import java.net.UnknownHostException;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.atomic.AtomicLong;
 
 import javax.servlet.ServletRequest;
@@ -40,7 +41,6 @@
 import org.eclipse.jetty.util.component.Dumpable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.eclipse.jetty.util.thread.ThreadPool;
 
 /**
  * Abstract Connector implementation. This abstract implementation of the Connector interface provides:
@@ -112,7 +112,7 @@
 	}
 
 	/* ------------------------------------------------------------ */
-	public ThreadPool getThreadPool()
+	public ThreadPoolExecutor getThreadPool()
 	{
 		return _server.getThreadPool();
 	}
@@ -297,11 +297,10 @@
 		{
 			_acceptorThreads = new Thread[getAcceptors()];
 
-			ThreadPool _threadPool = getThreadPool();
+			ThreadPoolExecutor _threadPool = getThreadPool();
 			for (int i = 0; i < _acceptorThreads.length; i++)
-				if (!_threadPool.dispatch(new Acceptor(i)))
-					throw new IllegalStateException("!accepting");
-			if (_threadPool.isLowOnThreads())
+				_threadPool.execute(new Acceptor(i));
+			if (_server.isLowOnThreads())
 				LOG.warn("insufficient threads configured for {}",this);
 		}
 
@@ -1012,9 +1011,9 @@
 	}
 
 	/* ------------------------------------------------------------ */
-	public boolean isLowResources()
+	public final boolean isLowResources()
 	{
-		return getThreadPool().isLowOnThreads();
+		return _server.isLowOnThreads();
 	}
 
 	/* ------------------------------------------------------------ */
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/AsyncContinuation.java
--- a/src/org/eclipse/jetty/server/AsyncContinuation.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/AsyncContinuation.java	Sun Oct 02 20:38:06 2016 -0600
@@ -50,1111 +50,1111 @@
  */
 public class AsyncContinuation implements AsyncContext, Continuation
 {
-    private static final Logger LOG = LoggerFactory.getLogger(AsyncContinuation.class);
+	private static final Logger LOG = LoggerFactory.getLogger(AsyncContinuation.class);
 
-    private final static long DEFAULT_TIMEOUT=30000L;
-    
-    private final static ContinuationThrowable __exception = new ContinuationThrowable();
-    
-    // STATES:
-    //               handling()    suspend()     unhandle()    resume()       complete()  doComplete()
-    //                             startAsync()                dispatch()   
-    // IDLE          DISPATCHED      
-    // DISPATCHED                  ASYNCSTARTED  UNCOMPLETED
-    // ASYNCSTARTED                              ASYNCWAIT     REDISPATCHING  COMPLETING
-    // REDISPATCHING                             REDISPATCHED  
-    // ASYNCWAIT                                               REDISPATCH     COMPLETING
-    // REDISPATCH    REDISPATCHED
-    // REDISPATCHED                ASYNCSTARTED  UNCOMPLETED
-    // COMPLETING    UNCOMPLETED                 UNCOMPLETED
-    // UNCOMPLETED                                                                        COMPLETED
-    // COMPLETED
-    private static final int __IDLE=0;         // Idle request
-    private static final int __DISPATCHED=1;   // Request dispatched to filter/servlet
-    private static final int __ASYNCSTARTED=2; // Suspend called, but not yet returned to container
-    private static final int __REDISPATCHING=3;// resumed while dispatched
-    private static final int __ASYNCWAIT=4;    // Suspended and parked
-    private static final int __REDISPATCH=5;   // Has been scheduled
-    private static final int __REDISPATCHED=6; // Request redispatched to filter/servlet
-    private static final int __COMPLETING=7;   // complete while dispatched
-    private static final int __UNCOMPLETED=8;  // Request is completable
-    private static final int __COMPLETED=9;    // Request is complete
-    
-    /* ------------------------------------------------------------ */
-    protected AbstractHttpConnection _connection;
-    private List<AsyncListener> _lastAsyncListeners;
-    private List<AsyncListener> _asyncListeners;
-    private List<ContinuationListener> _continuationListeners;
+	private final static long DEFAULT_TIMEOUT=30000L;
+	
+	private final static ContinuationThrowable __exception = new ContinuationThrowable();
+	
+	// STATES:
+	//               handling()    suspend()     unhandle()    resume()       complete()  doComplete()
+	//                             startAsync()                dispatch()   
+	// IDLE          DISPATCHED      
+	// DISPATCHED                  ASYNCSTARTED  UNCOMPLETED
+	// ASYNCSTARTED                              ASYNCWAIT     REDISPATCHING  COMPLETING
+	// REDISPATCHING                             REDISPATCHED  
+	// ASYNCWAIT                                               REDISPATCH     COMPLETING
+	// REDISPATCH    REDISPATCHED
+	// REDISPATCHED                ASYNCSTARTED  UNCOMPLETED
+	// COMPLETING    UNCOMPLETED                 UNCOMPLETED
+	// UNCOMPLETED                                                                        COMPLETED
+	// COMPLETED
+	private static final int __IDLE=0;         // Idle request
+	private static final int __DISPATCHED=1;   // Request dispatched to filter/servlet
+	private static final int __ASYNCSTARTED=2; // Suspend called, but not yet returned to container
+	private static final int __REDISPATCHING=3;// resumed while dispatched
+	private static final int __ASYNCWAIT=4;    // Suspended and parked
+	private static final int __REDISPATCH=5;   // Has been scheduled
+	private static final int __REDISPATCHED=6; // Request redispatched to filter/servlet
+	private static final int __COMPLETING=7;   // complete while dispatched
+	private static final int __UNCOMPLETED=8;  // Request is completable
+	private static final int __COMPLETED=9;    // Request is complete
+	
+	/* ------------------------------------------------------------ */
+	protected AbstractHttpConnection _connection;
+	private List<AsyncListener> _lastAsyncListeners;
+	private List<AsyncListener> _asyncListeners;
+	private List<ContinuationListener> _continuationListeners;
 
-    /* ------------------------------------------------------------ */
-    private int _state;
-    private boolean _initial;
-    private boolean _resumed;
-    private boolean _expired;
-    private volatile boolean _responseWrapped;
-    private long _timeoutMs=DEFAULT_TIMEOUT;
-    private AsyncEventState _event;
-    private volatile long _expireAt;    
-    private volatile boolean _continuation;
-    
-    /* ------------------------------------------------------------ */
-    protected AsyncContinuation()
-    {
-        _state=__IDLE;
-        _initial=true;
-    }
+	/* ------------------------------------------------------------ */
+	private int _state;
+	private boolean _initial;
+	private boolean _resumed;
+	private boolean _expired;
+	private volatile boolean _responseWrapped;
+	private long _timeoutMs=DEFAULT_TIMEOUT;
+	private AsyncEventState _event;
+	private volatile long _expireAt;    
+	private volatile boolean _continuation;
+	
+	/* ------------------------------------------------------------ */
+	protected AsyncContinuation()
+	{
+		_state=__IDLE;
+		_initial=true;
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void setConnection(final AbstractHttpConnection connection)
-    {
-        synchronized(this)
-        {
-            _connection=connection;
-        }
-    }
+	/* ------------------------------------------------------------ */
+	protected void setConnection(final AbstractHttpConnection connection)
+	{
+		synchronized(this)
+		{
+			_connection=connection;
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void addListener(AsyncListener listener)
-    {
-        synchronized(this)
-        {
-            if (_asyncListeners==null)
-                _asyncListeners=new ArrayList<AsyncListener>();
-            _asyncListeners.add(listener);
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public void addListener(AsyncListener listener)
+	{
+		synchronized(this)
+		{
+			if (_asyncListeners==null)
+				_asyncListeners=new ArrayList<AsyncListener>();
+			_asyncListeners.add(listener);
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void addListener(AsyncListener listener,ServletRequest request, ServletResponse response)
-    {
-        synchronized(this)
-        {
-            // TODO handle the request/response ???
-            if (_asyncListeners==null)
-                _asyncListeners=new ArrayList<AsyncListener>();
-            _asyncListeners.add(listener);
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public void addListener(AsyncListener listener,ServletRequest request, ServletResponse response)
+	{
+		synchronized(this)
+		{
+			// TODO handle the request/response ???
+			if (_asyncListeners==null)
+				_asyncListeners=new ArrayList<AsyncListener>();
+			_asyncListeners.add(listener);
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void addContinuationListener(ContinuationListener listener)
-    {
-        synchronized(this)
-        {
-            if (_continuationListeners==null)
-                _continuationListeners=new ArrayList<ContinuationListener>();
-            _continuationListeners.add(listener);
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public void addContinuationListener(ContinuationListener listener)
+	{
+		synchronized(this)
+		{
+			if (_continuationListeners==null)
+				_continuationListeners=new ArrayList<ContinuationListener>();
+			_continuationListeners.add(listener);
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void setTimeout(long ms)
-    {
-        synchronized(this)
-        {
-            _timeoutMs=ms;
-        }
-    } 
+	/* ------------------------------------------------------------ */
+	public void setTimeout(long ms)
+	{
+		synchronized(this)
+		{
+			_timeoutMs=ms;
+		}
+	} 
 
-    /* ------------------------------------------------------------ */
-    public long getTimeout()
-    {
-        synchronized(this)
-        {
-            return _timeoutMs;
-        }
-    } 
+	/* ------------------------------------------------------------ */
+	public long getTimeout()
+	{
+		synchronized(this)
+		{
+			return _timeoutMs;
+		}
+	} 
 
-    /* ------------------------------------------------------------ */
-    public AsyncEventState getAsyncEventState()
-    {
-        synchronized(this)
-        {
-            return _event;
-        }
-    } 
+	/* ------------------------------------------------------------ */
+	public AsyncEventState getAsyncEventState()
+	{
+		synchronized(this)
+		{
+			return _event;
+		}
+	} 
    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.continuation.Continuation#keepWrappers()
-     */
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.continuation.Continuation#keepWrappers()
+	 */
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.continuation.Continuation#isResponseWrapped()
-     */
-    public boolean isResponseWrapped()
-    {
-        return _responseWrapped;
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.continuation.Continuation#isResponseWrapped()
+	 */
+	public boolean isResponseWrapped()
+	{
+		return _responseWrapped;
+	}
 
-    /* ------------------------------------------------------------ */
-    /* (non-Javadoc)
-     * @see javax.servlet.ServletRequest#isInitial()
-     */
-    public boolean isInitial()
-    {
-        synchronized(this)
-        {
-            return _initial;
-        }
-    }
-    
-    public boolean isContinuation()
-    {
-        return _continuation;
-    }
-    
-    /* ------------------------------------------------------------ */
-    /* (non-Javadoc)
-     * @see javax.servlet.ServletRequest#isSuspended()
-     */
-    public boolean isSuspended()
-    {
-        synchronized(this)
-        {
-            switch(_state)
-            {
-                case __ASYNCSTARTED:
-                case __REDISPATCHING:
-                case __COMPLETING:
-                case __ASYNCWAIT:
-                    return true;
-                    
-                default:
-                    return false;   
-            }
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    public boolean isSuspending()
-    {
-        synchronized(this)
-        {
-            switch(_state)
-            {
-                case __ASYNCSTARTED:
-                case __ASYNCWAIT:
-                    return true;
-                    
-                default:
-                    return false;   
-            }
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    public boolean isDispatchable()
-    {
-        synchronized(this)
-        {
-            switch(_state)
-            {
-                case __REDISPATCH:
-                case __REDISPATCHED:
-                case __REDISPATCHING:
-                case __COMPLETING:
-                    return true;
-                    
-                default:
-                    return false;   
-            }
-        }
-    }
+	/* ------------------------------------------------------------ */
+	/* (non-Javadoc)
+	 * @see javax.servlet.ServletRequest#isInitial()
+	 */
+	public boolean isInitial()
+	{
+		synchronized(this)
+		{
+			return _initial;
+		}
+	}
+	
+	public boolean isContinuation()
+	{
+		return _continuation;
+	}
+	
+	/* ------------------------------------------------------------ */
+	/* (non-Javadoc)
+	 * @see javax.servlet.ServletRequest#isSuspended()
+	 */
+	public boolean isSuspended()
+	{
+		synchronized(this)
+		{
+			switch(_state)
+			{
+				case __ASYNCSTARTED:
+				case __REDISPATCHING:
+				case __COMPLETING:
+				case __ASYNCWAIT:
+					return true;
+					
+				default:
+					return false;   
+			}
+		}
+	}
+	
+	/* ------------------------------------------------------------ */
+	public boolean isSuspending()
+	{
+		synchronized(this)
+		{
+			switch(_state)
+			{
+				case __ASYNCSTARTED:
+				case __ASYNCWAIT:
+					return true;
+					
+				default:
+					return false;   
+			}
+		}
+	}
+	
+	/* ------------------------------------------------------------ */
+	public boolean isDispatchable()
+	{
+		synchronized(this)
+		{
+			switch(_state)
+			{
+				case __REDISPATCH:
+				case __REDISPATCHED:
+				case __REDISPATCHING:
+				case __COMPLETING:
+					return true;
+					
+				default:
+					return false;   
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    @Override
-    public String toString()
-    {
-        synchronized (this)
-        {
-            return super.toString()+"@"+getStatusString();
-        }
-    }
+	/* ------------------------------------------------------------ */
+	@Override
+	public String toString()
+	{
+		synchronized (this)
+		{
+			return super.toString()+"@"+getStatusString();
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public String getStatusString()
-    {
-        synchronized (this)
-        {
-            return
-            ((_state==__IDLE)?"IDLE":
-                (_state==__DISPATCHED)?"DISPATCHED":
-                    (_state==__ASYNCSTARTED)?"ASYNCSTARTED":
-                        (_state==__ASYNCWAIT)?"ASYNCWAIT":
-                            (_state==__REDISPATCHING)?"REDISPATCHING":
-                                (_state==__REDISPATCH)?"REDISPATCH":
-                                    (_state==__REDISPATCHED)?"REDISPATCHED":
-                                        (_state==__COMPLETING)?"COMPLETING":
-                                            (_state==__UNCOMPLETED)?"UNCOMPLETED":
-                                                (_state==__COMPLETED)?"COMPLETE":
-                                                    ("UNKNOWN?"+_state))+
-            (_initial?",initial":"")+
-            (_resumed?",resumed":"")+
-            (_expired?",expired":"");
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public String getStatusString()
+	{
+		synchronized (this)
+		{
+			return
+			((_state==__IDLE)?"IDLE":
+				(_state==__DISPATCHED)?"DISPATCHED":
+					(_state==__ASYNCSTARTED)?"ASYNCSTARTED":
+						(_state==__ASYNCWAIT)?"ASYNCWAIT":
+							(_state==__REDISPATCHING)?"REDISPATCHING":
+								(_state==__REDISPATCH)?"REDISPATCH":
+									(_state==__REDISPATCHED)?"REDISPATCHED":
+										(_state==__COMPLETING)?"COMPLETING":
+											(_state==__UNCOMPLETED)?"UNCOMPLETED":
+												(_state==__COMPLETED)?"COMPLETE":
+													("UNKNOWN?"+_state))+
+			(_initial?",initial":"")+
+			(_resumed?",resumed":"")+
+			(_expired?",expired":"");
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @return false if the handling of the request should not proceed
-     */
-    protected boolean handling()
-    {
-        synchronized (this)
-        {
-            _continuation=false;
-            
-            switch(_state)
-            {
-                case __IDLE:
-                    _initial=true;
-                    _state=__DISPATCHED;
-                    if (_lastAsyncListeners!=null)
-                        _lastAsyncListeners.clear();
-                    if (_asyncListeners!=null)
-                        _asyncListeners.clear();
-                    else
-                    {
-                        _asyncListeners=_lastAsyncListeners;
-                        _lastAsyncListeners=null;
-                    }
-                    return true;
-                    
-                case __COMPLETING:
-                    _state=__UNCOMPLETED;
-                    return false;
+	/* ------------------------------------------------------------ */
+	/**
+	 * @return false if the handling of the request should not proceed
+	 */
+	protected boolean handling()
+	{
+		synchronized (this)
+		{
+			_continuation=false;
+			
+			switch(_state)
+			{
+				case __IDLE:
+					_initial=true;
+					_state=__DISPATCHED;
+					if (_lastAsyncListeners!=null)
+						_lastAsyncListeners.clear();
+					if (_asyncListeners!=null)
+						_asyncListeners.clear();
+					else
+					{
+						_asyncListeners=_lastAsyncListeners;
+						_lastAsyncListeners=null;
+					}
+					return true;
+					
+				case __COMPLETING:
+					_state=__UNCOMPLETED;
+					return false;
 
-                case __ASYNCWAIT:
-                    return false;
-                    
-                case __REDISPATCH:
-                    _state=__REDISPATCHED;
-                    return true;
+				case __ASYNCWAIT:
+					return false;
+					
+				case __REDISPATCH:
+					_state=__REDISPATCHED;
+					return true;
 
-                default:
-                    throw new IllegalStateException(this.getStatusString());
-            }
-        }
-    }
+				default:
+					throw new IllegalStateException(this.getStatusString());
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /* (non-Javadoc)
-     * @see javax.servlet.ServletRequest#suspend(long)
-     */
-    private void doSuspend(final ServletContext context,
-            final ServletRequest request,
-            final ServletResponse response)
-    {
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __DISPATCHED:
-                case __REDISPATCHED:
-                    _resumed=false;
-                    _expired=false;
+	/* ------------------------------------------------------------ */
+	/* (non-Javadoc)
+	 * @see javax.servlet.ServletRequest#suspend(long)
+	 */
+	private void doSuspend(final ServletContext context,
+			final ServletRequest request,
+			final ServletResponse response)
+	{
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __DISPATCHED:
+				case __REDISPATCHED:
+					_resumed=false;
+					_expired=false;
 
-                    if (_event==null || request!=_event.getSuppliedRequest() || response != _event.getSuppliedResponse() || context != _event.getServletContext())
-                        _event=new AsyncEventState(context,request,response);
-                    else
-                    {
-                        _event._dispatchContext=null;
-                        _event._pathInContext=null;
-                    }
-                    _state=__ASYNCSTARTED;
-                    List<AsyncListener> recycle=_lastAsyncListeners;
-                    _lastAsyncListeners=_asyncListeners;
-                    _asyncListeners=recycle;
-                    if (_asyncListeners!=null)
-                        _asyncListeners.clear();
-                    break;
+					if (_event==null || request!=_event.getSuppliedRequest() || response != _event.getSuppliedResponse() || context != _event.getServletContext())
+						_event=new AsyncEventState(context,request,response);
+					else
+					{
+						_event._dispatchContext=null;
+						_event._pathInContext=null;
+					}
+					_state=__ASYNCSTARTED;
+					List<AsyncListener> recycle=_lastAsyncListeners;
+					_lastAsyncListeners=_asyncListeners;
+					_asyncListeners=recycle;
+					if (_asyncListeners!=null)
+						_asyncListeners.clear();
+					break;
 
-                default:
-                    throw new IllegalStateException(this.getStatusString());
-            }
-        }
-        
-        if (_lastAsyncListeners!=null)
-        {
-            for (AsyncListener listener : _lastAsyncListeners)
-            {
-                try
-                {
-                    listener.onStartAsync(_event);
-                }
-                catch(Exception e)
-                {
-                    LOG.warn("",e);
-                }
-            }
-        }
-    }
+				default:
+					throw new IllegalStateException(this.getStatusString());
+			}
+		}
+		
+		if (_lastAsyncListeners!=null)
+		{
+			for (AsyncListener listener : _lastAsyncListeners)
+			{
+				try
+				{
+					listener.onStartAsync(_event);
+				}
+				catch(Exception e)
+				{
+					LOG.warn("",e);
+				}
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * Signal that the HttpConnection has finished handling the request.
-     * For blocking connectors, this call may block if the request has
-     * been suspended (startAsync called).
-     * @return true if handling is complete, false if the request should 
-     * be handled again (eg because of a resume that happened before unhandle was called)
-     */
-    protected boolean unhandle()
-    {
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __REDISPATCHED:
-                case __DISPATCHED:
-                    _state=__UNCOMPLETED;
-                    return true;
+	/* ------------------------------------------------------------ */
+	/**
+	 * Signal that the HttpConnection has finished handling the request.
+	 * For blocking connectors, this call may block if the request has
+	 * been suspended (startAsync called).
+	 * @return true if handling is complete, false if the request should 
+	 * be handled again (eg because of a resume that happened before unhandle was called)
+	 */
+	protected boolean unhandle()
+	{
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __REDISPATCHED:
+				case __DISPATCHED:
+					_state=__UNCOMPLETED;
+					return true;
 
-                case __IDLE:
-                    throw new IllegalStateException(this.getStatusString());
+				case __IDLE:
+					throw new IllegalStateException(this.getStatusString());
 
-                case __ASYNCSTARTED:
-                    _initial=false;
-                    _state=__ASYNCWAIT;
-                    scheduleTimeout(); // could block and change state.
-                    if (_state==__ASYNCWAIT)
-                        return true;
-                    else if (_state==__COMPLETING)
-                    {
-                        _state=__UNCOMPLETED;
-                        return true;
-                    }         
-                    _initial=false;
-                    _state=__REDISPATCHED;
-                    return false; 
+				case __ASYNCSTARTED:
+					_initial=false;
+					_state=__ASYNCWAIT;
+					scheduleTimeout(); // could block and change state.
+					if (_state==__ASYNCWAIT)
+						return true;
+					else if (_state==__COMPLETING)
+					{
+						_state=__UNCOMPLETED;
+						return true;
+					}         
+					_initial=false;
+					_state=__REDISPATCHED;
+					return false; 
 
-                case __REDISPATCHING:
-                    _initial=false;
-                    _state=__REDISPATCHED;
-                    return false; 
+				case __REDISPATCHING:
+					_initial=false;
+					_state=__REDISPATCHED;
+					return false; 
 
-                case __COMPLETING:
-                    _initial=false;
-                    _state=__UNCOMPLETED;
-                    return true;
+				case __COMPLETING:
+					_initial=false;
+					_state=__UNCOMPLETED;
+					return true;
 
-                default:
-                    throw new IllegalStateException(this.getStatusString());
-            }
-        }
-    }
+				default:
+					throw new IllegalStateException(this.getStatusString());
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void dispatch()
-    {
-        boolean dispatch=false;
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __ASYNCSTARTED:
-                    _state=__REDISPATCHING;
-                    _resumed=true;
-                    return;
+	/* ------------------------------------------------------------ */
+	public void dispatch()
+	{
+		boolean dispatch=false;
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __ASYNCSTARTED:
+					_state=__REDISPATCHING;
+					_resumed=true;
+					return;
 
-                case __ASYNCWAIT:
-                    dispatch=!_expired;
-                    _state=__REDISPATCH;
-                    _resumed=true;
-                    break;
-                    
-                case __REDISPATCH:
-                    return;
-                    
-                default:
-                    throw new IllegalStateException(this.getStatusString());
-            }
-        }
-        
-        if (dispatch)
-        {
-            cancelTimeout();
-            scheduleDispatch();
-        }
-    }
+				case __ASYNCWAIT:
+					dispatch=!_expired;
+					_state=__REDISPATCH;
+					_resumed=true;
+					break;
+					
+				case __REDISPATCH:
+					return;
+					
+				default:
+					throw new IllegalStateException(this.getStatusString());
+			}
+		}
+		
+		if (dispatch)
+		{
+			cancelTimeout();
+			scheduleDispatch();
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void expired()
-    {
-        final List<ContinuationListener> cListeners;
-        final List<AsyncListener> aListeners;
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __ASYNCSTARTED:
-                case __ASYNCWAIT:
-                    cListeners=_continuationListeners;
-                    aListeners=_asyncListeners;
-                    break;
-                default:
-                    cListeners=null;
-                    aListeners=null;
-                    return;
-            }
-            _expired=true;
-        }
-        
-        if (aListeners!=null)
-        {
-            for (AsyncListener listener : aListeners)
-            {
-                try
-                {
-                    listener.onTimeout(_event);
-                }
-                catch(Exception e)
-                {
-                    LOG.debug("",e);
-                    _connection.getRequest().setAttribute(RequestDispatcher.ERROR_EXCEPTION,e);
-                    break;
-                }
-            }
-        }
-        if (cListeners!=null)
-        {
-            for (ContinuationListener listener : cListeners)
-            {
-                try
-                {
-                    listener.onTimeout(this);
-                }
-                catch(Exception e)
-                {
-                    LOG.warn("",e);
-                }
-            }
-        }
-        
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __ASYNCSTARTED:
-                case __ASYNCWAIT:
-                    dispatch();
-                    break;
-                    
-                default:
-                    if (!_continuation)
-                        _expired=false;
-            }
-        }
+	/* ------------------------------------------------------------ */
+	protected void expired()
+	{
+		final List<ContinuationListener> cListeners;
+		final List<AsyncListener> aListeners;
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __ASYNCSTARTED:
+				case __ASYNCWAIT:
+					cListeners=_continuationListeners;
+					aListeners=_asyncListeners;
+					break;
+				default:
+					cListeners=null;
+					aListeners=null;
+					return;
+			}
+			_expired=true;
+		}
+		
+		if (aListeners!=null)
+		{
+			for (AsyncListener listener : aListeners)
+			{
+				try
+				{
+					listener.onTimeout(_event);
+				}
+				catch(Exception e)
+				{
+					LOG.debug("",e);
+					_connection.getRequest().setAttribute(RequestDispatcher.ERROR_EXCEPTION,e);
+					break;
+				}
+			}
+		}
+		if (cListeners!=null)
+		{
+			for (ContinuationListener listener : cListeners)
+			{
+				try
+				{
+					listener.onTimeout(this);
+				}
+				catch(Exception e)
+				{
+					LOG.warn("",e);
+				}
+			}
+		}
+		
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __ASYNCSTARTED:
+				case __ASYNCWAIT:
+					dispatch();
+					break;
+					
+				default:
+					if (!_continuation)
+						_expired=false;
+			}
+		}
 
-        scheduleDispatch();
-    }
-    
-    /* ------------------------------------------------------------ */
-    /* (non-Javadoc)
-     * @see javax.servlet.ServletRequest#complete()
-     */
-    public void complete()
-    {
-        // just like resume, except don't set _resumed=true;
-        boolean dispatch=false;
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __DISPATCHED:
-                case __REDISPATCHED:
-                    throw new IllegalStateException(this.getStatusString());
+		scheduleDispatch();
+	}
+	
+	/* ------------------------------------------------------------ */
+	/* (non-Javadoc)
+	 * @see javax.servlet.ServletRequest#complete()
+	 */
+	public void complete()
+	{
+		// just like resume, except don't set _resumed=true;
+		boolean dispatch=false;
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __DISPATCHED:
+				case __REDISPATCHED:
+					throw new IllegalStateException(this.getStatusString());
 
-                case __ASYNCSTARTED:
-                    _state=__COMPLETING;
-                    return;
-                    
-                case __ASYNCWAIT:
-                    _state=__COMPLETING;
-                    dispatch=!_expired;
-                    break;
-                    
-                default:
-                    throw new IllegalStateException(this.getStatusString());
-            }
-        }
-        
-        if (dispatch)
-        {
-            cancelTimeout();
-            scheduleDispatch();
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    /* (non-Javadoc)
-     * @see javax.servlet.ServletRequest#complete()
-     */
-    public void errorComplete()
-    {
-        // just like complete except can overrule a prior dispatch call;
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __REDISPATCHING:
-                case __ASYNCSTARTED:
-                    _state=__COMPLETING;
-                    _resumed=false;
-                    return;
-                    
-                case __COMPLETING:
-                    return;
-                    
-                default:
-                    throw new IllegalStateException(this.getStatusString());
-            }
-        }
-    }
+				case __ASYNCSTARTED:
+					_state=__COMPLETING;
+					return;
+					
+				case __ASYNCWAIT:
+					_state=__COMPLETING;
+					dispatch=!_expired;
+					break;
+					
+				default:
+					throw new IllegalStateException(this.getStatusString());
+			}
+		}
+		
+		if (dispatch)
+		{
+			cancelTimeout();
+			scheduleDispatch();
+		}
+	}
+	
+	/* ------------------------------------------------------------ */
+	/* (non-Javadoc)
+	 * @see javax.servlet.ServletRequest#complete()
+	 */
+	public void errorComplete()
+	{
+		// just like complete except can overrule a prior dispatch call;
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __REDISPATCHING:
+				case __ASYNCSTARTED:
+					_state=__COMPLETING;
+					_resumed=false;
+					return;
+					
+				case __COMPLETING:
+					return;
+					
+				default:
+					throw new IllegalStateException(this.getStatusString());
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    @Override
-    public <T extends AsyncListener> T createListener(Class<T> clazz) throws ServletException 
-    {
-        try
-        {
-            // TODO inject
-            return clazz.newInstance();
-        }
-        catch(Exception e)
-        {
-            throw new ServletException(e);
-        }
-    }
+	/* ------------------------------------------------------------ */
+	@Override
+	public <T extends AsyncListener> T createListener(Class<T> clazz) throws ServletException 
+	{
+		try
+		{
+			// TODO inject
+			return clazz.newInstance();
+		}
+		catch(Exception e)
+		{
+			throw new ServletException(e);
+		}
+	}
 
 
-    /* ------------------------------------------------------------ */
-    /* (non-Javadoc)
-     * @see javax.servlet.ServletRequest#complete()
-     */
-    protected void doComplete(Throwable ex)
-    {
-        final List<ContinuationListener> cListeners;
-        final List<AsyncListener> aListeners;
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __UNCOMPLETED:
-                    _state=__COMPLETED;
-                    cListeners=_continuationListeners;
-                    aListeners=_asyncListeners;
-                    break;
-                    
-                default:
-                    cListeners=null;
-                    aListeners=null;
-                    throw new IllegalStateException(this.getStatusString());
-            }
-        }
-        
-        if (aListeners!=null)
-        {
-            for (AsyncListener listener : aListeners)
-            {
-                try
-                {
-                    if (ex!=null)
-                    {
-                        _event.getSuppliedRequest().setAttribute(RequestDispatcher.ERROR_EXCEPTION,ex);
-                        _event.getSuppliedRequest().setAttribute(RequestDispatcher.ERROR_MESSAGE,ex.getMessage());
-                        listener.onError(_event);
-                    }
-                    else
-                        listener.onComplete(_event);
-                }
-                catch(Exception e)
-                {
-                    LOG.warn("",e);
-                }
-            }
-        }
-        if (cListeners!=null)
-        {
-            for (ContinuationListener listener : cListeners)
-            {
-                try
-                {
-                    listener.onComplete(this);
-                }
-                catch(Exception e)
-                {
-                    LOG.warn("",e);
-                }
-            }
-        }
-    }
+	/* ------------------------------------------------------------ */
+	/* (non-Javadoc)
+	 * @see javax.servlet.ServletRequest#complete()
+	 */
+	protected void doComplete(Throwable ex)
+	{
+		final List<ContinuationListener> cListeners;
+		final List<AsyncListener> aListeners;
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __UNCOMPLETED:
+					_state=__COMPLETED;
+					cListeners=_continuationListeners;
+					aListeners=_asyncListeners;
+					break;
+					
+				default:
+					cListeners=null;
+					aListeners=null;
+					throw new IllegalStateException(this.getStatusString());
+			}
+		}
+		
+		if (aListeners!=null)
+		{
+			for (AsyncListener listener : aListeners)
+			{
+				try
+				{
+					if (ex!=null)
+					{
+						_event.getSuppliedRequest().setAttribute(RequestDispatcher.ERROR_EXCEPTION,ex);
+						_event.getSuppliedRequest().setAttribute(RequestDispatcher.ERROR_MESSAGE,ex.getMessage());
+						listener.onError(_event);
+					}
+					else
+						listener.onComplete(_event);
+				}
+				catch(Exception e)
+				{
+					LOG.warn("",e);
+				}
+			}
+		}
+		if (cListeners!=null)
+		{
+			for (ContinuationListener listener : cListeners)
+			{
+				try
+				{
+					listener.onComplete(this);
+				}
+				catch(Exception e)
+				{
+					LOG.warn("",e);
+				}
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void recycle()
-    {
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __DISPATCHED:
-                case __REDISPATCHED:
-                    throw new IllegalStateException(getStatusString());
-                default:
-                    _state=__IDLE;
-            }
-            _initial = true;
-            _resumed=false;
-            _expired=false;
-            _responseWrapped=false;
-            cancelTimeout();
-            _timeoutMs=DEFAULT_TIMEOUT;
-            _continuationListeners=null;
-        }
-    }    
-    
-    /* ------------------------------------------------------------ */
-    public void cancel()
-    {
-        synchronized (this)
-        {
-            cancelTimeout();
-            _continuationListeners=null;
-        }
-    }
+	/* ------------------------------------------------------------ */
+	protected void recycle()
+	{
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __DISPATCHED:
+				case __REDISPATCHED:
+					throw new IllegalStateException(getStatusString());
+				default:
+					_state=__IDLE;
+			}
+			_initial = true;
+			_resumed=false;
+			_expired=false;
+			_responseWrapped=false;
+			cancelTimeout();
+			_timeoutMs=DEFAULT_TIMEOUT;
+			_continuationListeners=null;
+		}
+	}    
+	
+	/* ------------------------------------------------------------ */
+	public void cancel()
+	{
+		synchronized (this)
+		{
+			cancelTimeout();
+			_continuationListeners=null;
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void scheduleDispatch()
-    {
-        EndPoint endp=_connection.getEndPoint();
-        if (!endp.isBlocking())
-        {
-            ((AsyncEndPoint)endp).asyncDispatch();
-        }
-    }
+	/* ------------------------------------------------------------ */
+	protected void scheduleDispatch()
+	{
+		EndPoint endp=_connection.getEndPoint();
+		if (!endp.isBlocking())
+		{
+			((AsyncEndPoint)endp).asyncDispatch();
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void scheduleTimeout()
-    {
-        EndPoint endp=_connection.getEndPoint();
-        if (_timeoutMs>0)
-        {
-            if (endp.isBlocking())
-            {
-                synchronized(this)
-                {
-                    _expireAt = System.currentTimeMillis()+_timeoutMs;
-                    long wait=_timeoutMs;
-                    while (_expireAt>0 && wait>0 && _connection.getServer().isRunning())
-                    {
-                        try
-                        {
-                            this.wait(wait);
-                        }
-                        catch (InterruptedException e)
-                        {
-                            LOG.trace("",e);
-                        }
-                        wait=_expireAt-System.currentTimeMillis();
-                    }
+	/* ------------------------------------------------------------ */
+	protected void scheduleTimeout()
+	{
+		EndPoint endp=_connection.getEndPoint();
+		if (_timeoutMs>0)
+		{
+			if (endp.isBlocking())
+			{
+				synchronized(this)
+				{
+					_expireAt = System.currentTimeMillis()+_timeoutMs;
+					long wait=_timeoutMs;
+					while (_expireAt>0 && wait>0 && _connection.getServer().isRunning())
+					{
+						try
+						{
+							this.wait(wait);
+						}
+						catch (InterruptedException e)
+						{
+							LOG.trace("",e);
+						}
+						wait=_expireAt-System.currentTimeMillis();
+					}
 
-                    if (_expireAt>0 && wait<=0 && _connection.getServer().isRunning())
-                    {
-                        expired();
-                    }
-                }            
-            }
-            else
-            {
-                ((AsyncEndPoint)endp).scheduleTimeout(_event._timeout,_timeoutMs);
-            }
-        }
-    }
+					if (_expireAt>0 && wait<=0 && _connection.getServer().isRunning())
+					{
+						expired();
+					}
+				}            
+			}
+			else
+			{
+				((AsyncEndPoint)endp).scheduleTimeout(_event._timeout,_timeoutMs);
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void cancelTimeout()
-    {
-        EndPoint endp=_connection.getEndPoint();
-        if (endp.isBlocking())
-        {
-            synchronized(this)
-            {
-                _expireAt=0;
-                this.notifyAll();
-            }
-        }
-        else 
-        {
-            final AsyncEventState event=_event;
-            if (event!=null)
-            {
-                ((AsyncEndPoint)endp).cancelTimeout(event._timeout);
-            }
-        }
-    }
+	/* ------------------------------------------------------------ */
+	protected void cancelTimeout()
+	{
+		EndPoint endp=_connection.getEndPoint();
+		if (endp.isBlocking())
+		{
+			synchronized(this)
+			{
+				_expireAt=0;
+				this.notifyAll();
+			}
+		}
+		else 
+		{
+			final AsyncEventState event=_event;
+			if (event!=null)
+			{
+				((AsyncEndPoint)endp).cancelTimeout(event._timeout);
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public boolean isCompleting()
-    {
-        synchronized (this)
-        {
-            return _state==__COMPLETING;
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    boolean isUncompleted()
-    {
-        synchronized (this)
-        {
-            return _state==__UNCOMPLETED;
-        }
-    } 
-    
-    /* ------------------------------------------------------------ */
-    public boolean isComplete()
-    {
-        synchronized (this)
-        {
-            return _state==__COMPLETED;
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public boolean isCompleting()
+	{
+		synchronized (this)
+		{
+			return _state==__COMPLETING;
+		}
+	}
+	
+	/* ------------------------------------------------------------ */
+	boolean isUncompleted()
+	{
+		synchronized (this)
+		{
+			return _state==__UNCOMPLETED;
+		}
+	} 
+	
+	/* ------------------------------------------------------------ */
+	public boolean isComplete()
+	{
+		synchronized (this)
+		{
+			return _state==__COMPLETED;
+		}
+	}
 
 
-    /* ------------------------------------------------------------ */
-    public boolean isAsyncStarted()
-    {
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __ASYNCSTARTED:
-                case __REDISPATCHING:
-                case __REDISPATCH:
-                case __ASYNCWAIT:
-                    return true;
+	/* ------------------------------------------------------------ */
+	public boolean isAsyncStarted()
+	{
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __ASYNCSTARTED:
+				case __REDISPATCHING:
+				case __REDISPATCH:
+				case __ASYNCWAIT:
+					return true;
 
-                default:
-                    return false;
-            }
-        }
-    }
+				default:
+					return false;
+			}
+		}
+	}
 
 
-    /* ------------------------------------------------------------ */
-    public boolean isAsync()
-    {
-        synchronized (this)
-        {
-            switch(_state)
-            {
-                case __IDLE:
-                case __DISPATCHED:
-                case __UNCOMPLETED:
-                case __COMPLETED:
-                    return false;
+	/* ------------------------------------------------------------ */
+	public boolean isAsync()
+	{
+		synchronized (this)
+		{
+			switch(_state)
+			{
+				case __IDLE:
+				case __DISPATCHED:
+				case __UNCOMPLETED:
+				case __COMPLETED:
+					return false;
 
-                default:
-                    return true;
-            }
-        }
-    }
+				default:
+					return true;
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public void dispatch(ServletContext context, String path)
-    {
-        _event._dispatchContext=context;
-        _event.setPath(path);
-        dispatch();
-    }
+	/* ------------------------------------------------------------ */
+	public void dispatch(ServletContext context, String path)
+	{
+		_event._dispatchContext=context;
+		_event.setPath(path);
+		dispatch();
+	}
 
-    /* ------------------------------------------------------------ */
-    public void dispatch(String path)
-    {
-        _event.setPath(path);
-        dispatch();
-    }
+	/* ------------------------------------------------------------ */
+	public void dispatch(String path)
+	{
+		_event.setPath(path);
+		dispatch();
+	}
 
-    /* ------------------------------------------------------------ */
-    public Request getBaseRequest()
-    {
-        return _connection.getRequest();
-    }
-    
-    /* ------------------------------------------------------------ */
-    public ServletRequest getRequest()
-    {
-        if (_event!=null)
-            return _event.getSuppliedRequest();
-        return _connection.getRequest();
-    }
+	/* ------------------------------------------------------------ */
+	public Request getBaseRequest()
+	{
+		return _connection.getRequest();
+	}
+	
+	/* ------------------------------------------------------------ */
+	public ServletRequest getRequest()
+	{
+		if (_event!=null)
+			return _event.getSuppliedRequest();
+		return _connection.getRequest();
+	}
 
-    /* ------------------------------------------------------------ */
-    public ServletResponse getResponse()
-    {
-        if (_responseWrapped && _event!=null && _event.getSuppliedResponse()!=null)
-            return _event.getSuppliedResponse();
-        return _connection.getResponse();
-    }
+	/* ------------------------------------------------------------ */
+	public ServletResponse getResponse()
+	{
+		if (_responseWrapped && _event!=null && _event.getSuppliedResponse()!=null)
+			return _event.getSuppliedResponse();
+		return _connection.getResponse();
+	}
 
-    /* ------------------------------------------------------------ */
-    public void start(final Runnable run)
-    {
-        final AsyncEventState event=_event;
-        if (event!=null)
-        {
-            _connection.getServer().getThreadPool().dispatch(new Runnable()
-            {
-                public void run()
-                {
-                    ((Context)event.getServletContext()).getContextHandler().handle(run);
-                }
-            });
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public void start(final Runnable run)
+	{
+		final AsyncEventState event=_event;
+		if (event!=null)
+		{
+			_connection.getServer().getThreadPool().execute(new Runnable()
+			{
+				public void run()
+				{
+					((Context)event.getServletContext()).getContextHandler().handle(run);
+				}
+			});
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public boolean hasOriginalRequestAndResponse()
-    {
-        synchronized (this)
-        {
-            return (_event!=null && _event.getSuppliedRequest()==_connection._request && _event.getSuppliedResponse()==_connection._response);
-        }
-    }
+	/* ------------------------------------------------------------ */
+	public boolean hasOriginalRequestAndResponse()
+	{
+		synchronized (this)
+		{
+			return (_event!=null && _event.getSuppliedRequest()==_connection._request && _event.getSuppliedResponse()==_connection._response);
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    public ContextHandler getContextHandler()
-    {
-        final AsyncEventState event=_event;
-        if (event!=null)
-            return ((Context)event.getServletContext()).getContextHandler();
-        return null;
-    }
+	/* ------------------------------------------------------------ */
+	public ContextHandler getContextHandler()
+	{
+		final AsyncEventState event=_event;
+		if (event!=null)
+			return ((Context)event.getServletContext()).getContextHandler();
+		return null;
+	}
 
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see Continuation#isResumed()
-     */
-    public boolean isResumed()
-    {
-        synchronized (this)
-        {
-            return _resumed;
-        }
-    }
-    /* ------------------------------------------------------------ */
-    /**
-     * @see Continuation#isExpired()
-     */
-    public boolean isExpired()
-    {
-        synchronized (this)
-        {
-            return _expired;
-        }
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see Continuation#isResumed()
+	 */
+	public boolean isResumed()
+	{
+		synchronized (this)
+		{
+			return _resumed;
+		}
+	}
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see Continuation#isExpired()
+	 */
+	public boolean isExpired()
+	{
+		synchronized (this)
+		{
+			return _expired;
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see Continuation#resume()
-     */
-    public void resume()
-    {
-        dispatch();
-    }
-    
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see Continuation#resume()
+	 */
+	public void resume()
+	{
+		dispatch();
+	}
+	
 
 
-    /* ------------------------------------------------------------ */
-    protected void startAsync(final ServletContext context,
-            final ServletRequest request,
-            final ServletResponse response)
-    {
-        synchronized (this)
-        {
-            _responseWrapped=!(response instanceof Response);
-            doSuspend(context,request,response);
-            if (request instanceof HttpServletRequest)
-            {
-                _event._pathInContext = URIUtil.addPaths(((HttpServletRequest)request).getServletPath(),((HttpServletRequest)request).getPathInfo());
-            }
-        }
-    }
+	/* ------------------------------------------------------------ */
+	protected void startAsync(final ServletContext context,
+			final ServletRequest request,
+			final ServletResponse response)
+	{
+		synchronized (this)
+		{
+			_responseWrapped=!(response instanceof Response);
+			doSuspend(context,request,response);
+			if (request instanceof HttpServletRequest)
+			{
+				_event._pathInContext = URIUtil.addPaths(((HttpServletRequest)request).getServletPath(),((HttpServletRequest)request).getPathInfo());
+			}
+		}
+	}
 
-    /* ------------------------------------------------------------ */
-    protected void startAsync()
-    {
-        _responseWrapped=false;
-        _continuation=false;
-        doSuspend(_connection.getRequest().getServletContext(),_connection.getRequest(),_connection.getResponse());  
-    }
+	/* ------------------------------------------------------------ */
+	protected void startAsync()
+	{
+		_responseWrapped=false;
+		_continuation=false;
+		doSuspend(_connection.getRequest().getServletContext(),_connection.getRequest(),_connection.getResponse());  
+	}
 
-    
-    /* ------------------------------------------------------------ */
-    /**
-     * @see Continuation#suspend()
-     */
-    public void suspend(ServletResponse response)
-    {
-        _continuation=true;
-        _responseWrapped=!(response instanceof Response);
-        doSuspend(_connection.getRequest().getServletContext(),_connection.getRequest(),response); 
-    }
+	
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see Continuation#suspend()
+	 */
+	public void suspend(ServletResponse response)
+	{
+		_continuation=true;
+		_responseWrapped=!(response instanceof Response);
+		doSuspend(_connection.getRequest().getServletContext(),_connection.getRequest(),response); 
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see Continuation#suspend()
-     */
-    public void suspend()
-    {
-        _responseWrapped=false;
-        _continuation=true;
-        doSuspend(_connection.getRequest().getServletContext(),_connection.getRequest(),_connection.getResponse());       
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see Continuation#suspend()
+	 */
+	public void suspend()
+	{
+		_responseWrapped=false;
+		_continuation=true;
+		doSuspend(_connection.getRequest().getServletContext(),_connection.getRequest(),_connection.getResponse());       
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.continuation.Continuation#getServletResponse()
-     */
-    public ServletResponse getServletResponse()
-    {
-        if (_responseWrapped && _event!=null && _event.getSuppliedResponse()!=null)
-            return _event.getSuppliedResponse();
-        return _connection.getResponse();
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.continuation.Continuation#getServletResponse()
+	 */
+	public ServletResponse getServletResponse()
+	{
+		if (_responseWrapped && _event!=null && _event.getSuppliedResponse()!=null)
+			return _event.getSuppliedResponse();
+		return _connection.getResponse();
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.continuation.Continuation#getAttribute(java.lang.String)
-     */
-    public Object getAttribute(String name)
-    {
-        return _connection.getRequest().getAttribute(name);
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.continuation.Continuation#getAttribute(java.lang.String)
+	 */
+	public Object getAttribute(String name)
+	{
+		return _connection.getRequest().getAttribute(name);
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.continuation.Continuation#removeAttribute(java.lang.String)
-     */
-    public void removeAttribute(String name)
-    {
-        _connection.getRequest().removeAttribute(name);
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.continuation.Continuation#removeAttribute(java.lang.String)
+	 */
+	public void removeAttribute(String name)
+	{
+		_connection.getRequest().removeAttribute(name);
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.continuation.Continuation#setAttribute(java.lang.String, java.lang.Object)
-     */
-    public void setAttribute(String name, Object attribute)
-    {
-        _connection.getRequest().setAttribute(name,attribute);
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.continuation.Continuation#setAttribute(java.lang.String, java.lang.Object)
+	 */
+	public void setAttribute(String name, Object attribute)
+	{
+		_connection.getRequest().setAttribute(name,attribute);
+	}
 
-    /* ------------------------------------------------------------ */
-    /**
-     * @see org.eclipse.jetty.continuation.Continuation#undispatch()
-     */
-    public void undispatch()
-    {
-        if (isSuspended())
-        {
-            if (LOG.isDebugEnabled())
-                throw new ContinuationThrowable();
-            else
-                throw __exception;
-        }
-        throw new IllegalStateException("!suspended");
-    }
+	/* ------------------------------------------------------------ */
+	/**
+	 * @see org.eclipse.jetty.continuation.Continuation#undispatch()
+	 */
+	public void undispatch()
+	{
+		if (isSuspended())
+		{
+			if (LOG.isDebugEnabled())
+				throw new ContinuationThrowable();
+			else
+				throw __exception;
+		}
+		throw new IllegalStateException("!suspended");
+	}
 
-    /* ------------------------------------------------------------ */
-    /* ------------------------------------------------------------ */
-    public class AsyncTimeout extends Timeout.Task implements Runnable
-    {
-            @Override
-            public void expired()
-            {
-                AsyncContinuation.this.expired();
-            }
+	/* ------------------------------------------------------------ */
+	/* ------------------------------------------------------------ */
+	public class AsyncTimeout extends Timeout.Task implements Runnable
+	{
+			@Override
+			public void expired()
+			{
+				AsyncContinuation.this.expired();
+			}
 
-            @Override
-            public void run()
-            {
-                AsyncContinuation.this.expired();
-            }
-    }
+			@Override
+			public void run()
+			{
+				AsyncContinuation.this.expired();
+			}
+	}
 
-    /* ------------------------------------------------------------ */
-    /* ------------------------------------------------------------ */
-    public class AsyncEventState extends AsyncEvent
-    {
-        private final ServletContext _suspendedContext;
-        private ServletContext _dispatchContext;
-        private String _pathInContext;
-        private Timeout.Task _timeout=  new AsyncTimeout();
-        
-        public AsyncEventState(ServletContext context, ServletRequest request, ServletResponse response)
-        {
-            super(AsyncContinuation.this, request,response);
-            _suspendedContext=context;
-            // Get the base request So we can remember the initial paths
-            Request r=_connection.getRequest();
+	/* ------------------------------------------------------------ */
+	/* ------------------------------------------------------------ */
+	public class AsyncEventState extends AsyncEvent
+	{
+		private final ServletContext _suspendedContext;
+		private ServletContext _dispatchContext;
+		private String _pathInContext;
+		private Timeout.Task _timeout=  new AsyncTimeout();
+		
+		public AsyncEventState(ServletContext context, ServletRequest request, ServletResponse response)
+		{
+			super(AsyncContinuation.this, request,response);
+			_suspendedContext=context;
+			// Get the base request So we can remember the initial paths
+			Request r=_connection.getRequest();
  
-            // If we haven't been async dispatched before
-            if (r.getAttribute(AsyncContext.ASYNC_REQUEST_URI)==null)
-            {
-                // We are setting these attributes during startAsync, when the spec implies that 
-                // they are only available after a call to AsyncContext.dispatch(...);
-                
-                // have we been forwarded before?
-                String uri=(String)r.getAttribute(RequestDispatcher.FORWARD_REQUEST_URI);
-                if (uri!=null)
-                {
-                    r.setAttribute(AsyncContext.ASYNC_REQUEST_URI,uri);
-                    r.setAttribute(AsyncContext.ASYNC_CONTEXT_PATH,r.getAttribute(RequestDispatcher.FORWARD_CONTEXT_PATH));
-                    r.setAttribute(AsyncContext.ASYNC_SERVLET_PATH,r.getAttribute(RequestDispatcher.FORWARD_SERVLET_PATH));
-                    r.setAttribute(AsyncContext.ASYNC_PATH_INFO,r.getAttribute(RequestDispatcher.FORWARD_PATH_INFO));
-                    r.setAttribute(AsyncContext.ASYNC_QUERY_STRING,r.getAttribute(RequestDispatcher.FORWARD_QUERY_STRING));
-                }
-                else
-                {
-                    r.setAttribute(AsyncContext.ASYNC_REQUEST_URI,r.getRequestURI());
-                    r.setAttribute(AsyncContext.ASYNC_CONTEXT_PATH,r.getContextPath());
-                    r.setAttribute(AsyncContext.ASYNC_SERVLET_PATH,r.getServletPath());
-                    r.setAttribute(AsyncContext.ASYNC_PATH_INFO,r.getPathInfo());
-                    r.setAttribute(AsyncContext.ASYNC_QUERY_STRING,r.getQueryString());
-                }
-            }
-        }
-        
-        public ServletContext getSuspendedContext()
-        {
-            return _suspendedContext;
-        }
-        
-        public ServletContext getDispatchContext()
-        {
-            return _dispatchContext;
-        }
-        
-        public ServletContext getServletContext()
-        {
-            return _dispatchContext==null?_suspendedContext:_dispatchContext;
-        }
-        
-        public void setPath(String path)
-        {
-            _pathInContext=path;
-        }
-        
-        /* ------------------------------------------------------------ */
-        /**
-         * @return The path in the context
-         */
-        public String getPath()
-        {
-            return _pathInContext;
-        }
-    }
+			// If we haven't been async dispatched before
+			if (r.getAttribute(AsyncContext.ASYNC_REQUEST_URI)==null)
+			{
+				// We are setting these attributes during startAsync, when the spec implies that 
+				// they are only available after a call to AsyncContext.dispatch(...);
+				
+				// have we been forwarded before?
+				String uri=(String)r.getAttribute(RequestDispatcher.FORWARD_REQUEST_URI);
+				if (uri!=null)
+				{
+					r.setAttribute(AsyncContext.ASYNC_REQUEST_URI,uri);
+					r.setAttribute(AsyncContext.ASYNC_CONTEXT_PATH,r.getAttribute(RequestDispatcher.FORWARD_CONTEXT_PATH));
+					r.setAttribute(AsyncContext.ASYNC_SERVLET_PATH,r.getAttribute(RequestDispatcher.FORWARD_SERVLET_PATH));
+					r.setAttribute(AsyncContext.ASYNC_PATH_INFO,r.getAttribute(RequestDispatcher.FORWARD_PATH_INFO));
+					r.setAttribute(AsyncContext.ASYNC_QUERY_STRING,r.getAttribute(RequestDispatcher.FORWARD_QUERY_STRING));
+				}
+				else
+				{
+					r.setAttribute(AsyncContext.ASYNC_REQUEST_URI,r.getRequestURI());
+					r.setAttribute(AsyncContext.ASYNC_CONTEXT_PATH,r.getContextPath());
+					r.setAttribute(AsyncContext.ASYNC_SERVLET_PATH,r.getServletPath());
+					r.setAttribute(AsyncContext.ASYNC_PATH_INFO,r.getPathInfo());
+					r.setAttribute(AsyncContext.ASYNC_QUERY_STRING,r.getQueryString());
+				}
+			}
+		}
+		
+		public ServletContext getSuspendedContext()
+		{
+			return _suspendedContext;
+		}
+		
+		public ServletContext getDispatchContext()
+		{
+			return _dispatchContext;
+		}
+		
+		public ServletContext getServletContext()
+		{
+			return _dispatchContext==null?_suspendedContext:_dispatchContext;
+		}
+		
+		public void setPath(String path)
+		{
+			_pathInContext=path;
+		}
+		
+		/* ------------------------------------------------------------ */
+		/**
+		 * @return The path in the context
+		 */
+		public String getPath()
+		{
+			return _pathInContext;
+		}
+	}
 }
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/Connector.java
--- a/src/org/eclipse/jetty/server/Connector.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/Connector.java	Sun Oct 02 20:38:06 2016 -0600
@@ -23,7 +23,6 @@
 import org.eclipse.jetty.io.Buffers;
 import org.eclipse.jetty.io.EndPoint;
 import org.eclipse.jetty.util.component.LifeCycle;
-import org.eclipse.jetty.util.thread.ThreadPool;
 
 /** HTTP Connector.
  * Implementations of this interface provide connectors for the HTTP protocol.
@@ -267,7 +266,7 @@
 	/* ------------------------------------------------------------ */
 	/** Check if low on resources.
 	 * For most connectors, low resources is measured by calling 
-	 * {@link ThreadPool#isLowOnThreads()} on the connector threadpool
+	 * {@link Server#isLowOnThreads()} on the connector threadpool
 	 * or the server threadpool if there is no connector threadpool.
 	 * <p>
 	 * For blocking connectors, low resources is used to trigger
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/Server.java
--- a/src/org/eclipse/jetty/server/Server.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/Server.java	Sun Oct 02 20:38:06 2016 -0600
@@ -21,6 +21,9 @@
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.util.Enumeration;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
@@ -40,9 +43,7 @@
 import org.eclipse.jetty.util.component.LifeCycle;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.eclipse.jetty.util.thread.QueuedThreadPool;
 import org.eclipse.jetty.util.thread.ShutdownThread;
-import org.eclipse.jetty.util.thread.ThreadPool;
 
 /* ------------------------------------------------------------ */
 /** Jetty HTTP Servlet Server.
@@ -60,7 +61,7 @@
 	private static final String __version = "8";
 
 	private final AttributesMap _attributes = new AttributesMap();
-	private final ThreadPool _threadPool;
+	private final ThreadPoolExecutor _threadPool;
 	private Connector[] _connectors;
 	private boolean _sendServerVersion = true; //send Server: header
 	private boolean _sendDateHeader = false; //send Date: header
@@ -83,7 +84,7 @@
 		connector.setPort(port);
 		setConnectors(new Connector[]{connector});
 
-		_threadPool = new QueuedThreadPool();
+		_threadPool = new ThreadPoolExecutor(256, 256, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
 		addBean(_threadPool);
 	}
 
@@ -165,7 +166,7 @@
 	/**
 	 * @return Returns the threadPool.
 	 */
-	public ThreadPool getThreadPool()
+	public ThreadPoolExecutor getThreadPool()
 	{
 		return _threadPool;
 	}
@@ -358,7 +359,8 @@
 	/* ------------------------------------------------------------ */
 	public void join() throws InterruptedException
 	{
-		getThreadPool().join();
+//		getThreadPool().join();
+		_threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
 	}
 
 	/* ------------------------------------------------------------ */
@@ -515,6 +517,16 @@
 		public void setShutdown(boolean shutdown);
 	}
 
+
+	public final boolean isLowOnThreads()
+	{
+		ThreadPoolExecutor tpe = getThreadPool();
+		// getActiveCount() locks the thread pool, so execute it last
+		return tpe.getPoolSize() == tpe.getMaximumPoolSize() &&
+				tpe.getQueue().size() >= tpe.getPoolSize() - tpe.getActiveCount();
+	}
+
+
 	/* ------------------------------------------------------------ */
 	public static void main(String...args) throws Exception
 	{
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/bio/SocketConnector.java
--- a/src/org/eclipse/jetty/server/bio/SocketConnector.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/bio/SocketConnector.java	Sun Oct 02 20:38:06 2016 -0600
@@ -25,6 +25,8 @@
 import java.net.SocketException;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadPoolExecutor;
 
 import org.eclipse.jetty.http.HttpException;
 import org.eclipse.jetty.io.Buffer;
@@ -56,270 +58,274 @@
  */
 public class SocketConnector extends AbstractConnector
 {
-    private static final Logger LOG = LoggerFactory.getLogger(SocketConnector.class);
+	private static final Logger LOG = LoggerFactory.getLogger(SocketConnector.class);
 
-    protected ServerSocket _serverSocket;
-    protected final Set<EndPoint> _connections;
-    protected volatile int _localPort=-1;
+	protected ServerSocket _serverSocket;
+	protected final Set<EndPoint> _connections;
+	protected volatile int _localPort=-1;
 
-    /* ------------------------------------------------------------ */
-    /** Constructor.
-     *
-     */
-    public SocketConnector()
-    {
-        _connections=new HashSet<EndPoint>();
-    }
+	/* ------------------------------------------------------------ */
+	/** Constructor.
+	 *
+	 */
+	public SocketConnector()
+	{
+		_connections=new HashSet<EndPoint>();
+	}
 
-    /* ------------------------------------------------------------ */
-    public Object getConnection()
-    {
-        return _serverSocket;
-    }
+	/* ------------------------------------------------------------ */
+	public Object getConnection()
+	{
+		return _serverSocket;
+	}
 
-    /* ------------------------------------------------------------ */
-    public void open() throws IOException
-    {
-        // Create a new server socket and set to non blocking mode
-        if (_serverSocket==null || _serverSocket.isClosed())
-        _serverSocket= newServerSocket(getHost(),getPort(),getAcceptQueueSize());
-        _serverSocket.setReuseAddress(getReuseAddress());
-        _localPort=_serverSocket.getLocalPort();
-        if (_localPort<=0)
-            throw new IllegalStateException("port not allocated for "+this);
+	/* ------------------------------------------------------------ */
+	public void open() throws IOException
+	{
+		// Create a new server socket and set to non blocking mode
+		if (_serverSocket==null || _serverSocket.isClosed())
+		_serverSocket= newServerSocket(getHost(),getPort(),getAcceptQueueSize());
+		_serverSocket.setReuseAddress(getReuseAddress());
+		_localPort=_serverSocket.getLocalPort();
+		if (_localPort<=0)
+			throw new IllegalStateException("port not allocated for "+this);
 
-    }
+	}
 
-    /* ------------------------------------------------------------ */
-    protected ServerSocket newServerSocket(String host, int port,int backlog) throws IOException
-    {
-        ServerSocket ss= host==null?
-            new ServerSocket(port,backlog):
-            new ServerSocket(port,backlog,InetAddress.getByName(host));
+	/* ------------------------------------------------------------ */
+	protected ServerSocket newServerSocket(String host, int port,int backlog) throws IOException
+	{
+		ServerSocket ss= host==null?
+			new ServerSocket(port,backlog):
+			new ServerSocket(port,backlog,InetAddress.getByName(host));
 
-        return ss;
-    }
+		return ss;
+	}
 
-    /* ------------------------------------------------------------ */
-    public void close() throws IOException
-    {
-        if (_serverSocket!=null)
-            _serverSocket.close();
-        _serverSocket=null;
-        _localPort=-2;
-    }
+	/* ------------------------------------------------------------ */
+	public void close() throws IOException
+	{
+		if (_serverSocket!=null)
+			_serverSocket.close();
+		_serverSocket=null;
+		_localPort=-2;
+	}
 
-    /* ------------------------------------------------------------ */
-    @Override
-    public void accept(int acceptorID)
-    	throws IOException, InterruptedException
-    {
-        Socket socket = _serverSocket.accept();
-        configure(socket);
+	/* ------------------------------------------------------------ */
+	@Override
+	public void accept(int acceptorID)
+		throws IOException, InterruptedException
+	{
+		Socket socket = _serverSocket.accept();
+		configure(socket);
 
-        ConnectorEndPoint connection=new ConnectorEndPoint(socket);
-        connection.dispatch();
-    }
+		ConnectorEndPoint connection=new ConnectorEndPoint(socket);
+		connection.dispatch();
+	}
 
-    /* ------------------------------------------------------------------------------- */
-    /**
-     * Allows subclass to override Conection if required.
-     */
-    protected Connection newConnection(EndPoint endpoint)
-    {
-        return new BlockingHttpConnection(this, endpoint, getServer());
-    }
+	/* ------------------------------------------------------------------------------- */
+	/**
+	 * Allows subclass to override Conection if required.
+	 */
+	protected Connection newConnection(EndPoint endpoint)
+	{
+		return new BlockingHttpConnection(this, endpoint, getServer());
+	}
 
-    /* ------------------------------------------------------------------------------- */
-    @Override
-    public void customize(EndPoint endpoint, Request request)
-        throws IOException
-    {
-        ConnectorEndPoint connection = (ConnectorEndPoint)endpoint;
-        int lrmit = isLowResources()?_lowResourceMaxIdleTime:_maxIdleTime;
-        connection.setMaxIdleTime(lrmit);
+	/* ------------------------------------------------------------------------------- */
+	@Override
+	public void customize(EndPoint endpoint, Request request)
+		throws IOException
+	{
+		ConnectorEndPoint connection = (ConnectorEndPoint)endpoint;
+		int lrmit = isLowResources()?_lowResourceMaxIdleTime:_maxIdleTime;
+		connection.setMaxIdleTime(lrmit);
 
-        super.customize(endpoint, request);
-    }
+		super.customize(endpoint, request);
+	}
 
-    /* ------------------------------------------------------------------------------- */
-    public int getLocalPort()
-    {
-        return _localPort;
-    }
+	/* ------------------------------------------------------------------------------- */
+	public int getLocalPort()
+	{
+		return _localPort;
+	}
 
-    /* ------------------------------------------------------------------------------- */
-    @Override
-    protected void doStart() throws Exception
-    {
-        _connections.clear();
-        super.doStart();
-    }
+	/* ------------------------------------------------------------------------------- */
+	@Override
+	protected void doStart() throws Exception
+	{
+		_connections.clear();
+		super.doStart();
+	}
 
-    /* ------------------------------------------------------------------------------- */
-    @Override
-    protected void doStop() throws Exception
-    {
-        super.doStop();
-        Set<EndPoint> set = new HashSet<EndPoint>();
-        synchronized(_connections)
-        {
-            set.addAll(_connections);
-        }
-        for (EndPoint endPoint : set)
-        {
-            ConnectorEndPoint connection = (ConnectorEndPoint)endPoint;
-            connection.close();
-        }
-    }
+	/* ------------------------------------------------------------------------------- */
+	@Override
+	protected void doStop() throws Exception
+	{
+		super.doStop();
+		Set<EndPoint> set = new HashSet<EndPoint>();
+		synchronized(_connections)
+		{
+			set.addAll(_connections);
+		}
+		for (EndPoint endPoint : set)
+		{
+			ConnectorEndPoint connection = (ConnectorEndPoint)endPoint;
+			connection.close();
+		}
+	}
 
-    @Override
-    public void dump(Appendable out, String indent) throws IOException
-    {
-        super.dump(out, indent);
-        Set<EndPoint> connections = new HashSet<EndPoint>();
-        synchronized (_connections)
-        {
-            connections.addAll(_connections);
-        }
-        AggregateLifeCycle.dump(out, indent, connections);
-    }
+	@Override
+	public void dump(Appendable out, String indent) throws IOException
+	{
+		super.dump(out, indent);
+		Set<EndPoint> connections = new HashSet<EndPoint>();
+		synchronized (_connections)
+		{
+			connections.addAll(_connections);
+		}
+		AggregateLifeCycle.dump(out, indent, connections);
+	}
 
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    /* ------------------------------------------------------------------------------- */
-    protected class ConnectorEndPoint extends SocketEndPoint implements Runnable, ConnectedEndPoint
-    {
-        volatile Connection _connection;
-        protected final Socket _socket;
+	/* ------------------------------------------------------------------------------- */
+	/* ------------------------------------------------------------------------------- */
+	/* ------------------------------------------------------------------------------- */
+	protected class ConnectorEndPoint extends SocketEndPoint implements Runnable, ConnectedEndPoint
+	{
+		volatile Connection _connection;
+		protected final Socket _socket;
 
-        public ConnectorEndPoint(Socket socket) throws IOException
-        {
-            super(socket,_maxIdleTime);
-            _connection = newConnection(this);
-            _socket=socket;
-        }
+		public ConnectorEndPoint(Socket socket) throws IOException
+		{
+			super(socket,_maxIdleTime);
+			_connection = newConnection(this);
+			_socket=socket;
+		}
 
-        public Connection getConnection()
-        {
-            return _connection;
-        }
+		public Connection getConnection()
+		{
+			return _connection;
+		}
 
-        public void setConnection(Connection connection)
-        {
-            if (_connection!=connection && _connection!=null)
-                connectionUpgraded(_connection,connection);
-            _connection=connection;
-        }
+		public void setConnection(Connection connection)
+		{
+			if (_connection!=connection && _connection!=null)
+				connectionUpgraded(_connection,connection);
+			_connection=connection;
+		}
 
-        public void dispatch() throws IOException
-        {
-            if (getThreadPool()==null || !getThreadPool().dispatch(this))
-            {
-                LOG.warn("dispatch failed for {}",_connection);
-                close();
-            }
-        }
+		public void dispatch() throws IOException
+		{
+			ThreadPoolExecutor tpe = getThreadPool();
+			if( tpe != null ) {
+				try {
+					tpe.execute(this);
+					return;
+				} catch(RejectedExecutionException e) {}
+			}
+			LOG.warn("dispatch failed for {}",_connection);
+			close();
+		}
 
-        @Override
-        public int fill(Buffer buffer) throws IOException
-        {
-            int l = super.fill(buffer);
-            if (l<0)
-            {
-                if (!isInputShutdown())
-                    shutdownInput();
-                if (isOutputShutdown())
-                    close();
-            }
-            return l;
-        }
+		@Override
+		public int fill(Buffer buffer) throws IOException
+		{
+			int l = super.fill(buffer);
+			if (l<0)
+			{
+				if (!isInputShutdown())
+					shutdownInput();
+				if (isOutputShutdown())
+					close();
+			}
+			return l;
+		}
 
-        @Override
-        public void close() throws IOException
-        {
-            if (_connection instanceof AbstractHttpConnection)
-                ((AbstractHttpConnection)_connection).getRequest().getAsyncContinuation().cancel();
-            super.close();
-        }
-
-        public void run()
-        {
-            try
-            {
-                connectionOpened(_connection);
-                synchronized(_connections)
-                {
-                    _connections.add(this);
-                }
+		@Override
+		public void close() throws IOException
+		{
+			if (_connection instanceof AbstractHttpConnection)
+				((AbstractHttpConnection)_connection).getRequest().getAsyncContinuation().cancel();
+			super.close();
+		}
 
-                while (isStarted() && !isClosed())
-                {
-                    if (_connection.isIdle())
-                    {
-                        if (isLowResources())
-                            setMaxIdleTime(getLowResourcesMaxIdleTime());
-                    }
+		public void run()
+		{
+			try
+			{
+				connectionOpened(_connection);
+				synchronized(_connections)
+				{
+					_connections.add(this);
+				}
+
+				while (isStarted() && !isClosed())
+				{
+					if (_connection.isIdle())
+					{
+						if (isLowResources())
+							setMaxIdleTime(getLowResourcesMaxIdleTime());
+					}
 
-                    _connection=_connection.handle();
-                }
-            }
-            catch (EofException e)
-            {
-                LOG.debug("EOF", e);
-                try{close();}
-                catch(IOException e2){LOG.trace("",e2);}
-            }
-            catch (SocketException e)
-            {
-                LOG.debug("EOF", e);
-                try{close();}
-                catch(IOException e2){LOG.trace("",e2);}
-            }
-            catch (HttpException e)
-            {
-                LOG.debug("BAD", e);
-                try{close();}
-                catch(IOException e2){LOG.trace("",e2);}
-            }
-            catch(Exception e)
-            {
-                LOG.warn("handle failed?",e);
-                try{close();}
-                catch(IOException e2){LOG.trace("",e2);}
-            }
-            finally
-            {
-                connectionClosed(_connection);
-                synchronized(_connections)
-                {
-                    _connections.remove(this);
-                }
+					_connection=_connection.handle();
+				}
+			}
+			catch (EofException e)
+			{
+				LOG.debug("EOF", e);
+				try{close();}
+				catch(IOException e2){LOG.trace("",e2);}
+			}
+			catch (SocketException e)
+			{
+				LOG.debug("EOF", e);
+				try{close();}
+				catch(IOException e2){LOG.trace("",e2);}
+			}
+			catch (HttpException e)
+			{
+				LOG.debug("BAD", e);
+				try{close();}
+				catch(IOException e2){LOG.trace("",e2);}
+			}
+			catch(Exception e)
+			{
+				LOG.warn("handle failed?",e);
+				try{close();}
+				catch(IOException e2){LOG.trace("",e2);}
+			}
+			finally
+			{
+				connectionClosed(_connection);
+				synchronized(_connections)
+				{
+					_connections.remove(this);
+				}
 
-                // wait for client to close, but if not, close ourselves.
-                try
-                {
-                    if (!_socket.isClosed())
-                    {
-                        long timestamp=System.currentTimeMillis();
-                        int max_idle=getMaxIdleTime();
+				// wait for client to close, but if not, close ourselves.
+				try
+				{
+					if (!_socket.isClosed())
+					{
+						long timestamp=System.currentTimeMillis();
+						int max_idle=getMaxIdleTime();
 
-                        _socket.setSoTimeout(getMaxIdleTime());
-                        int c=0;
-                        do
-                        {
-                            c = _socket.getInputStream().read();
-                        }
-                        while (c>=0 && (System.currentTimeMillis()-timestamp)<max_idle);
-                        if (!_socket.isClosed())
-                            _socket.close();
-                    }
-                }
-                catch(IOException e)
-                {
-                    LOG.trace("",e);
-                }
-            }
-        }
-    }
+						_socket.setSoTimeout(getMaxIdleTime());
+						int c=0;
+						do
+						{
+							c = _socket.getInputStream().read();
+						}
+						while (c>=0 && (System.currentTimeMillis()-timestamp)<max_idle);
+						if (!_socket.isClosed())
+							_socket.close();
+					}
+				}
+				catch(IOException e)
+				{
+					LOG.trace("",e);
+				}
+			}
+		}
+	}
 }
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/handler/HandlerCollection.java
--- a/src/org/eclipse/jetty/server/handler/HandlerCollection.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/handler/HandlerCollection.java	Sun Oct 02 20:38:06 2016 -0600
@@ -193,7 +193,7 @@
 				for (int i=0;i<_handlers.length;i++)
 				{
 					final int h=i;
-					getServer().getThreadPool().dispatch(
+					getServer().getThreadPool().execute(
 							new Runnable()
 							{
 								public void run()
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/nio/BlockingChannelConnector.java
--- a/src/org/eclipse/jetty/server/nio/BlockingChannelConnector.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/nio/BlockingChannelConnector.java	Sun Oct 02 20:38:06 2016 -0600
@@ -27,6 +27,7 @@
 import java.nio.channels.SocketChannel;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.RejectedExecutionException;
 
 import org.eclipse.jetty.http.HttpException;
 import org.eclipse.jetty.io.Buffer;
@@ -83,7 +84,7 @@
 	protected void doStart() throws Exception
 	{
 		super.doStart();
-		getThreadPool().dispatch(new Runnable()
+		getThreadPool().execute(new Runnable()
 		{
 
 			public void run()
@@ -224,8 +225,9 @@
 		/* ------------------------------------------------------------ */
 		void dispatch() throws IOException
 		{
-			if (!getThreadPool().dispatch(this))
-			{
+			try {
+				getThreadPool().execute(this);
+			} catch(RejectedExecutionException e) {
 				LOG.warn("dispatch failed for  {}",_connection);
 				super.close();
 			}
@@ -278,7 +280,7 @@
 					_idleTimestamp=System.currentTimeMillis();
 					if (_connection.isIdle())
 					{
-						if (getServer().getThreadPool().isLowOnThreads())
+						if (getServer().isLowOnThreads())
 						{
 							int lrmit = getLowResourcesMaxIdleTime();
 							if (lrmit>=0 && _timeout!= lrmit)
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/nio/InheritedChannelConnector.java
--- a/src/org/eclipse/jetty/server/nio/InheritedChannelConnector.java	Sun Oct 02 16:17:38 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +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.nio;
-
-import java.io.IOException;
-import java.nio.channels.Channel;
-import java.nio.channels.ServerSocketChannel;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * An implementation of the SelectChannelConnector which first tries to  
- * inherit from a channel provided by the system. If there is no inherited
- * channel available, or if the inherited channel provided not usable, then 
- * it will fall back upon normal ServerSocketChannel creation.
- * <p> 
- * Note that System.inheritedChannel() is only available from Java 1.5 onwards.
- * Trying to use this class under Java 1.4 will be the same as using a normal
- * SelectChannelConnector. 
- * <p> 
- * Use it with xinetd/inetd, to launch an instance of Jetty on demand. The port
- * used to access pages on the Jetty instance is the same as the port used to
- * launch Jetty. 
- * 
- * @author athena
- */
-public class InheritedChannelConnector extends SelectChannelConnector
-{
-    private static final Logger LOG = LoggerFactory.getLogger(InheritedChannelConnector.class);
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void open() throws IOException
-    {
-        synchronized(this)
-        {
-            try 
-            {
-                Channel channel = System.inheritedChannel();
-                if ( channel instanceof ServerSocketChannel )
-                    _acceptChannel = (ServerSocketChannel)channel;
-                else
-                    LOG.warn("Unable to use System.inheritedChannel() [" +channel+ "]. Trying a new ServerSocketChannel at " + getHost() + ":" + getPort());
-                
-                if ( _acceptChannel != null )
-                    _acceptChannel.configureBlocking(true);
-            }
-            catch(NoSuchMethodError e)
-            {
-                LOG.warn("Need at least Java 5 to use socket inherited from xinetd/inetd.");
-            }
-
-            if (_acceptChannel == null)
-                super.open();
-        }
-    }
-
-}
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/server/nio/SelectChannelConnector.java
--- a/src/org/eclipse/jetty/server/nio/SelectChannelConnector.java	Sun Oct 02 16:17:38 2016 -0600
+++ b/src/org/eclipse/jetty/server/nio/SelectChannelConnector.java	Sun Oct 02 20:38:06 2016 -0600
@@ -36,7 +36,6 @@
 import org.eclipse.jetty.io.nio.SelectorManager.SelectSet;
 import org.eclipse.jetty.server.AsyncHttpConnection;
 import org.eclipse.jetty.server.Request;
-import org.eclipse.jetty.util.thread.ThreadPool;
 
 /* ------------------------------------------------------------------------------- */
 /**
@@ -283,12 +282,9 @@
 	private final class ConnectorSelectorManager extends SelectorManager
 	{
 		@Override
-		public boolean dispatch(Runnable task)
+		public void execute(Runnable task)
 		{
-			ThreadPool pool=getThreadPool();
-			if (pool==null)
-				pool=getServer().getThreadPool();
-			return pool.dispatch(task);
+			getThreadPool().execute(task);
 		}
 
 		@Override
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/util/BlockingArrayQueue.java
--- a/src/org/eclipse/jetty/util/BlockingArrayQueue.java	Sun Oct 02 16:17:38 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,704 +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;
-
-import java.util.AbstractList;
-import java.util.Collection;
-import java.util.NoSuchElementException;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.ReentrantLock;
-
-
-/* ------------------------------------------------------------ */
-/** Queue backed by a circular array.
- * 
- * This queue is uses  a variant of the two lock queue algorithm to
- * provide an efficient queue or list backed by a growable circular
- * array.  This queue also has a partial implementation of 
- * {@link java.util.concurrent.BlockingQueue}, specifically the {@link #take()} and 
- * {@link #poll(long, TimeUnit)} methods.  
- * Unlike {@link java.util.concurrent.ArrayBlockingQueue}, this class is
- * able to grow and provides a blocking put call.
- * <p>
- * The queue has both a capacity (the size of the array currently allocated)
- * and a limit (the maximum size that may be allocated), which defaults to 
- * {@link Integer#MAX_VALUE}.
- * 
- * @param <E> The element type
- */
-public class BlockingArrayQueue<E> extends AbstractList<E> implements BlockingQueue<E>
-{
-    public final int DEFAULT_CAPACITY=128;
-    public final int DEFAULT_GROWTH=64;
-    private final int _limit;
-    private final AtomicInteger _size=new AtomicInteger();
-    private final int _growCapacity;
-    
-    private volatile int _capacity;
-    private Object[] _elements;
-    
-    private final ReentrantLock _headLock = new ReentrantLock();
-    private final Condition _notEmpty = _headLock.newCondition();
-    private int _head;
-
-    // spacers created to prevent false sharing between head and tail http://en.wikipedia.org/wiki/False_sharing
-    // TODO verify this has benefits
-    private long _space0;
-    private long _space1;
-    private long _space2;
-    private long _space3;
-    private long _space4;
-    private long _space5;
-    private long _space6;
-    private long _space7;
-    
-    private final ReentrantLock _tailLock = new ReentrantLock();
-    private int _tail;
-    
-
-    /* ------------------------------------------------------------ */
-    /** Create a growing partially blocking Queue
-     * 
-     */
-    public BlockingArrayQueue()
-    {
-        _elements=new Object[DEFAULT_CAPACITY];
-        _growCapacity=DEFAULT_GROWTH;
-        _capacity=_elements.length;
-        _limit=Integer.MAX_VALUE;
-    }
-
-    /* ------------------------------------------------------------ */
-    /** Create a fixed size partially blocking Queue
-     * @param limit The initial capacity and the limit.
-     */
-    public BlockingArrayQueue(int limit)
-    {
-        _elements=new Object[limit];
-        _capacity=_elements.length;
-        _growCapacity=-1;
-        _limit=limit;
-    }
-
-    /* ------------------------------------------------------------ */
-    /** Create a growing partially blocking Queue.
-     * @param capacity Initial capacity
-     * @param growBy Incremental capacity.
-     */
-    public BlockingArrayQueue(int capacity,int growBy)
-    {
-        _elements=new Object[capacity];
-        _capacity=_elements.length;
-        _growCapacity=growBy;
-        _limit=Integer.MAX_VALUE;
-    }
-
-    /* ------------------------------------------------------------ */
-    /** Create a growing limited partially blocking Queue.
-     * @param capacity Initial capacity
-     * @param growBy Incremental capacity.
-     * @param limit maximum capacity.
-     */
-    public BlockingArrayQueue(int capacity,int growBy,int limit)
-    {
-        if (capacity>limit)
-            throw new IllegalArgumentException();
-        
-        _elements=new Object[capacity];
-        _capacity=_elements.length;
-        _growCapacity=growBy;
-        _limit=limit;
-    }
-
-    /* ------------------------------------------------------------ */
-    public int getCapacity()
-    {
-        return _capacity;
-    }
-
-    /* ------------------------------------------------------------ */
-    public int getLimit()
-    {
-        return _limit;
-    }
-    
-    /* ------------------------------------------------------------ */
-    @Override
-    public boolean add(E e)
-    {
-        return offer(e);
-    }
-    
-    /* ------------------------------------------------------------ */
-    public E element()
-    {
-        E e = peek();
-        if (e==null)
-            throw new NoSuchElementException();
-        return e;
-    }
-    
-    /* ------------------------------------------------------------ */
-    @SuppressWarnings("unchecked")
-    public E peek()
-    {
-        if (_size.get() == 0)
-            return null;
-        
-        E e = null;
-        _headLock.lock(); // Size cannot shrink
-        try 
-        {
-            if (_size.get() > 0) 
-                e = (E)_elements[_head];
-        } 
-        finally 
-        {
-            _headLock.unlock();
-        }
-        
-        return e;
-    }
-
-    /* ------------------------------------------------------------ */
-    public boolean offer(E e)
-    {
-        if (e == null) 
-            throw new NullPointerException();
-        
-        boolean not_empty=false;
-        _tailLock.lock();  // size cannot grow... only shrink
-        try 
-        {
-            if (_size.get() >= _limit) 
-                return false;
-            
-            // should we expand array?
-            if (_size.get()==_capacity)
-            {
-                _headLock.lock();   // Need to grow array
-                try
-                {
-                    if (!grow())
-                        return false;
-                }
-                finally
-                {
-                    _headLock.unlock();
-                }
-            }
-
-            // add the element
-            _elements[_tail]=e;
-            _tail=(_tail+1)%_capacity;
-
-            not_empty=0==_size.getAndIncrement();
-            
-        } 
-        finally 
-        {
-            _tailLock.unlock();
-        }
-        
-        if (not_empty)
-        {
-            _headLock.lock();
-            try
-            {
-                _notEmpty.signal();
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }  
-
-        return true;
-    }
-
-
-    /* ------------------------------------------------------------ */
-    @SuppressWarnings("unchecked")
-    public E poll()
-    {
-        if (_size.get() == 0)
-            return null;
-        
-        E e = null;
-        _headLock.lock(); // Size cannot shrink
-        try 
-        {
-            if (_size.get() > 0) 
-            {
-                final int head=_head;
-                e = (E)_elements[head];
-                _elements[head]=null;
-                _head=(head+1)%_capacity;
-                
-                if (_size.decrementAndGet()>0)
-                    _notEmpty.signal();
-            }
-        } 
-        finally 
-        {
-            _headLock.unlock();
-        }
-        
-        return e;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Retrieves and removes the head of this queue, waiting
-     * if no elements are present on this queue.
-     * @return the head of this queue
-     * @throws InterruptedException if interrupted while waiting.
-     */
-    @SuppressWarnings("unchecked")
-    public E take() throws InterruptedException
-    {
-        E e = null;
-        _headLock.lockInterruptibly();  // Size cannot shrink
-        try 
-        {
-            try 
-            {
-                while (_size.get() == 0)
-                {
-                    _notEmpty.await();
-                }
-            } 
-            catch (InterruptedException ie) 
-            {
-                _notEmpty.signal();
-                throw ie;
-            }
-
-            final int head=_head;
-            e = (E)_elements[head];
-            _elements[head]=null;
-            _head=(head+1)%_capacity;
-
-            if (_size.decrementAndGet()>0)
-                _notEmpty.signal();
-        } 
-        finally 
-        {
-            _headLock.unlock();
-        }
-        
-        return e;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Retrieves and removes the head of this queue, waiting
-     * if necessary up to the specified wait time if no elements are
-     * present on this queue.
-     * @param time how long to wait before giving up, in units of
-     * <tt>unit</tt>
-     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
-     * <tt>timeout</tt> parameter
-     * @return the head of this queue, or <tt>null</tt> if the
-     * specified waiting time elapses before an element is present.
-     * @throws InterruptedException if interrupted while waiting.
-     */
-    @SuppressWarnings("unchecked")
-    public E poll(long time, TimeUnit unit) throws InterruptedException
-    {
-        
-        E e = null;
-
-        long nanos = unit.toNanos(time);
-        
-        _headLock.lockInterruptibly(); // Size cannot shrink
-        try 
-        {    
-            try 
-            {
-                while (_size.get() == 0)
-                {
-                    if (nanos<=0)
-                        return null;
-                    nanos = _notEmpty.awaitNanos(nanos);
-                }
-            } 
-            catch (InterruptedException ie) 
-            {
-                _notEmpty.signal();
-                throw ie;
-            }
-
-            e = (E)_elements[_head];
-            _elements[_head]=null;
-            _head=(_head+1)%_capacity;
-
-            if (_size.decrementAndGet()>0)
-                _notEmpty.signal();
-        } 
-        finally 
-        {
-            _headLock.unlock();
-        }
-        
-        return e;
-    }
-
-    /* ------------------------------------------------------------ */
-    public E remove()
-    {
-        E e=poll();
-        if (e==null)
-            throw new NoSuchElementException();
-        return e;
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void clear()
-    {
-        _tailLock.lock();
-        try
-        {
-            _headLock.lock();
-            try
-            {
-                _head=0;
-                _tail=0;
-                _size.set(0);
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }
-        finally
-        {
-            _tailLock.unlock();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public boolean isEmpty()
-    {
-        return _size.get()==0;
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public int size()
-    {
-        return _size.get();
-    }
-
-    /* ------------------------------------------------------------ */
-    @SuppressWarnings("unchecked")
-    @Override
-    public E get(int index)
-    {
-        _tailLock.lock();
-        try
-        {
-            _headLock.lock();
-            try
-            {
-                if (index<0 || index>=_size.get())
-                    throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")");
-                int i = _head+index;
-                if (i>=_capacity)
-                    i-=_capacity;
-                return (E)_elements[i];
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }
-        finally
-        {
-            _tailLock.unlock();
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    @Override
-    public E remove(int index)
-    {
-        _tailLock.lock();
-        try
-        {
-            _headLock.lock();
-            try
-            {
-
-                if (index<0 || index>=_size.get())
-                    throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")");
-
-                int i = _head+index;
-                if (i>=_capacity)
-                    i-=_capacity;
-                @SuppressWarnings("unchecked")
-                E old=(E)_elements[i];
-
-                if (i<_tail)
-                {
-                    System.arraycopy(_elements,i+1,_elements,i,_tail-i);
-                    _tail--;
-                    _size.decrementAndGet();
-                }
-                else
-                {
-                    System.arraycopy(_elements,i+1,_elements,i,_capacity-i-1);
-                    if (_tail>0)
-                    {
-                        _elements[_capacity]=_elements[0];
-                        System.arraycopy(_elements,1,_elements,0,_tail-1);
-                        _tail--;
-                    }
-                    else
-                        _tail=_capacity-1;
-
-                    _size.decrementAndGet();
-                }
-
-                return old;
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }
-        finally
-        {
-            _tailLock.unlock();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public E set(int index, E e)
-    {
-        if (e == null) 
-            throw new NullPointerException();
-
-        _tailLock.lock();
-        try
-        {
-            _headLock.lock();
-            try
-            {
-
-                if (index<0 || index>=_size.get())
-                    throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")");
-
-                int i = _head+index;
-                if (i>=_capacity)
-                    i-=_capacity;
-                @SuppressWarnings("unchecked")
-                E old=(E)_elements[i];
-                _elements[i]=e;
-                return old;
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }
-        finally
-        {
-            _tailLock.unlock();
-        }
-    }
-    
-    /* ------------------------------------------------------------ */
-    @Override
-    public void add(int index, E e)
-    {
-        if (e == null) 
-            throw new NullPointerException();
-
-        _tailLock.lock();
-        try
-        {
-            _headLock.lock();
-            try
-            {
-
-                if (index<0 || index>_size.get())
-                    throw new IndexOutOfBoundsException("!("+0+"<"+index+"<="+_size+")");
-
-                if (index==_size.get())
-                {
-                    add(e);
-                }
-                else
-                {
-                    if (_tail==_head)
-                        if (!grow())
-                            throw new IllegalStateException("full");
-
-                    int i = _head+index;
-                    if (i>=_capacity)
-                        i-=_capacity;
-
-                    _size.incrementAndGet();
-                    _tail=(_tail+1)%_capacity;
-
-
-                    if (i<_tail)
-                    {
-                        System.arraycopy(_elements,i,_elements,i+1,_tail-i);
-                        _elements[i]=e;
-                    }
-                    else
-                    {
-                        if (_tail>0)
-                        {
-                            System.arraycopy(_elements,0,_elements,1,_tail);
-                            _elements[0]=_elements[_capacity-1];
-                        }
-
-                        System.arraycopy(_elements,i,_elements,i+1,_capacity-i-1);
-                        _elements[i]=e;
-                    }
-                }
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }
-        finally
-        {
-            _tailLock.unlock();
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    private boolean grow()
-    {
-        if (_growCapacity<=0)
-            return false;
-
-        _tailLock.lock();
-        try
-        {
-            _headLock.lock();
-            try
-            {
-                final int head=_head;
-                final int tail=_tail;
-                final int new_tail;
-
-                Object[] elements=new Object[_capacity+_growCapacity];
-
-                if (head<tail)
-                {
-                    new_tail=tail-head;
-                    System.arraycopy(_elements,head,elements,0,new_tail);
-                }
-                else if (head>tail || _size.get()>0)
-                {
-                    new_tail=_capacity+tail-head;
-                    int cut=_capacity-head;
-                    System.arraycopy(_elements,head,elements,0,cut);
-                    System.arraycopy(_elements,0,elements,cut,tail);
-                }
-                else
-                {
-                    new_tail=0;
-                }
-
-                _elements=elements;
-                _capacity=_elements.length;
-                _head=0;
-                _tail=new_tail; 
-                return true;
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }
-        finally
-        {
-            _tailLock.unlock();
-        }
-
-    }
-
-    /* ------------------------------------------------------------ */
-    public int drainTo(Collection<? super E> c)
-    {
-        throw new UnsupportedOperationException();
-    }
-
-    /* ------------------------------------------------------------ */
-    public int drainTo(Collection<? super E> c, int maxElements)
-    {
-        throw new UnsupportedOperationException();
-    }
-
-    /* ------------------------------------------------------------ */
-    public boolean offer(E o, long timeout, TimeUnit unit) throws InterruptedException
-    {
-        throw new UnsupportedOperationException();
-    }
-
-    /* ------------------------------------------------------------ */
-    public void put(E o) throws InterruptedException
-    {
-        if (!add(o))
-            throw new IllegalStateException("full");
-    }
-
-    /* ------------------------------------------------------------ */
-    public int remainingCapacity()
-    {
-        _tailLock.lock();
-        try
-        {
-            _headLock.lock();
-            try
-            {
-                return getCapacity()-size();
-            }
-            finally
-            {
-                _headLock.unlock();
-            }
-        }
-        finally
-        {
-            _tailLock.unlock();
-        }
-    }
-    
-
-    /* ------------------------------------------------------------ */
-    long sumOfSpace()
-    {
-        // this method exists to stop clever optimisers removing the spacers
-        return _space0++ +_space1++ +_space2++ +_space3++ +_space4++ +_space5++ +_space6++ +_space7++; 
-    }
-}
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/util/thread/ExecutorThreadPool.java
--- a/src/org/eclipse/jetty/util/thread/ExecutorThreadPool.java	Sun Oct 02 16:17:38 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,184 +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.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.SynchronousQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-import org.eclipse.jetty.util.component.AbstractLifeCycle;
-import org.eclipse.jetty.util.component.LifeCycle;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/* ------------------------------------------------------------ */
-/**
- * Jetty ThreadPool using java 5 ThreadPoolExecutor
- * This class wraps a {@link ExecutorService} as a {@link ThreadPool} and
- * {@link LifeCycle} interfaces so that it may be used by the Jetty <code>org.eclipse.jetty.server.Server</code>
- */
-public class ExecutorThreadPool extends AbstractLifeCycle implements ThreadPool, LifeCycle
-{
-    private static final Logger LOG = LoggerFactory.getLogger(ExecutorThreadPool.class);
-    private final ExecutorService _executor;
-
-    /* ------------------------------------------------------------ */
-    public ExecutorThreadPool(ExecutorService executor)
-    {
-        _executor = executor;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Wraps an {@link ThreadPoolExecutor}.
-     * Max pool size is 256, pool thread timeout after 60 seconds and
-     * an unbounded {@link LinkedBlockingQueue} is used for the job queue;
-     */
-    public ExecutorThreadPool()
-    {
-        // Using an unbounded queue makes the maxThreads parameter useless
-        // Refer to ThreadPoolExecutor javadocs for details
-        this(new ThreadPoolExecutor(256, 256, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()));
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Wraps an {@link ThreadPoolExecutor}.
-     * Max pool size is 256, pool thread timeout after 60 seconds, and core pool size is 32 when queueSize >= 0.
-     * @param queueSize can be -1 for using an unbounded {@link LinkedBlockingQueue}, 0 for using a
-     * {@link SynchronousQueue}, greater than 0 for using a {@link ArrayBlockingQueue} of the given size.
-     */
-    public ExecutorThreadPool(int queueSize)
-    {
-        this(queueSize < 0 ? new ThreadPoolExecutor(256, 256, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()) :
-                queueSize == 0 ? new ThreadPoolExecutor(32, 256, 60, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()) :
-                        new ThreadPoolExecutor(32, 256, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueSize)));
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Wraps an {@link ThreadPoolExecutor} using
-     * an unbounded {@link LinkedBlockingQueue} is used for the jobs queue;
-     * @param corePoolSize must be equal to maximumPoolSize
-     * @param maximumPoolSize the maximum number of threads to allow in the pool
-     * @param keepAliveTime the max time a thread can remain idle, in milliseconds
-     */
-    public ExecutorThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime)
-    {
-        this(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS);
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Wraps an {@link ThreadPoolExecutor} using
-     * an unbounded {@link LinkedBlockingQueue} is used for the jobs queue.
-     * @param corePoolSize must be equal to maximumPoolSize
-     * @param maximumPoolSize the maximum number of threads to allow in the pool
-     * @param keepAliveTime the max time a thread can remain idle
-     * @param unit the unit for the keepAliveTime
-     */
-    public ExecutorThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit)
-    {
-        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, new LinkedBlockingQueue<Runnable>());
-    }
-
-    /* ------------------------------------------------------------ */
-
-    /**
-     * Wraps an {@link ThreadPoolExecutor}
-     * @param corePoolSize the number of threads to keep in the pool, even if they are idle
-     * @param maximumPoolSize the maximum number of threads to allow in the pool
-     * @param keepAliveTime the max time a thread can remain idle
-     * @param unit the unit for the keepAliveTime
-     * @param workQueue the queue to use for holding tasks before they are executed
-     */
-    public ExecutorThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
-    {
-        this(new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue));
-    }
-
-    /* ------------------------------------------------------------ */
-    public boolean dispatch(Runnable job)
-    {
-        try
-        {
-            _executor.execute(job);
-            return true;
-        }
-        catch(RejectedExecutionException e)
-        {
-            LOG.warn("",e);
-            return false;
-        }
-    }
-
-    /* ------------------------------------------------------------ */
-    public int getIdleThreads()
-    {
-        if (_executor instanceof ThreadPoolExecutor)
-        {
-            final ThreadPoolExecutor tpe = (ThreadPoolExecutor)_executor;
-            return tpe.getPoolSize() - tpe.getActiveCount();
-        }
-        return -1;
-    }
-
-    /* ------------------------------------------------------------ */
-    public int getThreads()
-    {
-        if (_executor instanceof ThreadPoolExecutor)
-        {
-            final ThreadPoolExecutor tpe = (ThreadPoolExecutor)_executor;
-            return tpe.getPoolSize();
-        }
-        return -1;
-    }
-
-    /* ------------------------------------------------------------ */
-    public boolean isLowOnThreads()
-    {
-        if (_executor instanceof ThreadPoolExecutor)
-        {
-            final ThreadPoolExecutor tpe = (ThreadPoolExecutor)_executor;
-            // getActiveCount() locks the thread pool, so execute it last
-            return tpe.getPoolSize() == tpe.getMaximumPoolSize() &&
-                    tpe.getQueue().size() >= tpe.getPoolSize() - tpe.getActiveCount();
-        }
-        return false;
-    }
-
-    /* ------------------------------------------------------------ */
-    public void join() throws InterruptedException
-    {
-        _executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    protected void doStop() throws Exception
-    {
-        super.doStop();
-        _executor.shutdownNow();
-    }
-}
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/util/thread/QueuedThreadPool.java
--- a/src/org/eclipse/jetty/util/thread/QueuedThreadPool.java	Sun Oct 02 16:17:38 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,677 +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.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.Executor;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-
-import org.eclipse.jetty.util.BlockingArrayQueue;
-import org.eclipse.jetty.util.component.AbstractLifeCycle;
-import org.eclipse.jetty.util.component.AggregateLifeCycle;
-import org.eclipse.jetty.util.component.Dumpable;
-import org.eclipse.jetty.util.component.LifeCycle;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class QueuedThreadPool extends AbstractLifeCycle implements ThreadPool, Executor, Dumpable
-{
-	private static final Logger LOG = LoggerFactory.getLogger(QueuedThreadPool.class);
-
-	private final AtomicInteger _threadsStarted = new AtomicInteger();
-	private final AtomicInteger _threadsIdle = new AtomicInteger();
-	private final AtomicLong _lastShrink = new AtomicLong();
-	private final ConcurrentLinkedQueue<Thread> _threads=new ConcurrentLinkedQueue<Thread>();
-	private final Object _joinLock = new Object();
-	private BlockingQueue<Runnable> _jobs;
-	private String _name;
-	private int _maxIdleTimeMs=60000;
-	private int _maxThreads=254;
-	private int _minThreads=8;
-	private int _maxQueued=-1;
-	private int _priority=Thread.NORM_PRIORITY;
-	private boolean _daemon=false;
-	private int _maxStopTime=100;
-	private boolean _detailedDump=false;
-
-	/* ------------------------------------------------------------------- */
-	/** Construct
-	 */
-	public QueuedThreadPool()
-	{
-		_name="qtp"+super.hashCode();
-	}
-
-	/* ------------------------------------------------------------------- */
-	/** Construct
-	 */
-	public QueuedThreadPool(int maxThreads)
-	{
-		this();
-		setMaxThreads(maxThreads);
-	}
-
-	/* ------------------------------------------------------------------- */
-	/** Construct
-	 */
-	public QueuedThreadPool(BlockingQueue<Runnable> jobQ)
-	{
-		this();
-		_jobs=jobQ;
-		_jobs.clear();
-	}
-
-
-	/* ------------------------------------------------------------ */
-	@Override
-	protected void doStart() throws Exception
-	{
-		super.doStart();
-		_threadsStarted.set(0);
-
-		if (_jobs==null)
-		{
-			_jobs=_maxQueued>0 ?new ArrayBlockingQueue<Runnable>(_maxQueued)
-				:new BlockingArrayQueue<Runnable>(_minThreads,_minThreads);
-		}
-
-		int threads=_threadsStarted.get();
-		while (isRunning() && threads<_minThreads)
-		{
-			startThread(threads);
-			threads=_threadsStarted.get();
-		}
-	}
-
-	/* ------------------------------------------------------------ */
-	@Override
-	protected void doStop() throws Exception
-	{
-		super.doStop();
-		long start=System.currentTimeMillis();
-
-		// let jobs complete naturally for a while
-		while (_threadsStarted.get()>0 && (System.currentTimeMillis()-start) < (_maxStopTime/2))
-			Thread.sleep(1);
-
-		// kill queued jobs and flush out idle jobs
-		_jobs.clear();
-		Runnable noop = new Runnable(){public void run(){}};
-		for  (int i=_threadsIdle.get();i-->0;)
-			_jobs.offer(noop);
-		Thread.yield();
-
-		// interrupt remaining threads
-		if (_threadsStarted.get()>0)
-			for (Thread thread : _threads)
-				thread.interrupt();
-
-		// wait for remaining threads to die
-		while (_threadsStarted.get()>0 && (System.currentTimeMillis()-start) < _maxStopTime)
-		{
-			Thread.sleep(1);
-		}
-		Thread.yield();
-		int size=_threads.size();
-		if (size>0)
-		{
-			LOG.warn(size+" threads could not be stopped");
-
-			if (size==1 || LOG.isDebugEnabled())
-			{
-				for (Thread unstopped : _threads)
-				{
-					LOG.info("Couldn't stop "+unstopped);
-					for (StackTraceElement element : unstopped.getStackTrace())
-					{
-						LOG.info(" at "+element);
-					}
-				}
-			}
-		}
-
-		synchronized (_joinLock)
-		{
-			_joinLock.notifyAll();
-		}
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * Delegated to the named or anonymous Pool.
-	 */
-	public void setDaemon(boolean daemon)
-	{
-		_daemon=daemon;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Set the maximum thread idle time.
-	 * Threads that are idle for longer than this period may be
-	 * stopped.
-	 * Delegated to the named or anonymous Pool.
-	 * @see #getMaxIdleTimeMs
-	 * @param maxIdleTimeMs Max idle time in ms.
-	 */
-	public void setMaxIdleTimeMs(int maxIdleTimeMs)
-	{
-		_maxIdleTimeMs=maxIdleTimeMs;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @param stopTimeMs maximum total time that stop() will wait for threads to die.
-	 */
-	public void setMaxStopTimeMs(int stopTimeMs)
-	{
-		_maxStopTime = stopTimeMs;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Set the maximum number of threads.
-	 * Delegated to the named or anonymous Pool.
-	 * @see #getMaxThreads
-	 * @param maxThreads maximum number of threads.
-	 */
-	public void setMaxThreads(int maxThreads)
-	{
-		_maxThreads=maxThreads;
-		if (_minThreads>_maxThreads)
-			_minThreads=_maxThreads;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Set the minimum number of threads.
-	 * Delegated to the named or anonymous Pool.
-	 * @see #getMinThreads
-	 * @param minThreads minimum number of threads
-	 */
-	public void setMinThreads(int minThreads)
-	{
-		_minThreads=minThreads;
-
-		if (_minThreads>_maxThreads)
-			_maxThreads=_minThreads;
-
-		int threads=_threadsStarted.get();
-		while (isStarted() && threads<_minThreads)
-		{
-			startThread(threads);
-			threads=_threadsStarted.get();
-		}
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @param name Name of the BoundedThreadPool to use when naming Threads.
-	 */
-	public void setName(String name)
-	{
-		if (isRunning())
-			throw new IllegalStateException("started");
-		_name= name;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Set the priority of the pool threads.
-	 *  @param priority the new thread priority.
-	 */
-	public void setThreadsPriority(int priority)
-	{
-		_priority=priority;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return maximum queue size
-	 */
-	public int getMaxQueued()
-	{
-		return _maxQueued;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @param max job queue size
-	 */
-	public void setMaxQueued(int max)
-	{
-		if (isRunning())
-			throw new IllegalStateException("started");
-		_maxQueued=max;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Get the maximum thread idle time.
-	 * Delegated to the named or anonymous Pool.
-	 * @see #setMaxIdleTimeMs
-	 * @return Max idle time in ms.
-	 */
-	public int getMaxIdleTimeMs()
-	{
-		return _maxIdleTimeMs;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return maximum total time that stop() will wait for threads to die.
-	 */
-	public int getMaxStopTimeMs()
-	{
-		return _maxStopTime;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Set the maximum number of threads.
-	 * Delegated to the named or anonymous Pool.
-	 * @see #setMaxThreads
-	 * @return maximum number of threads.
-	 */
-	public int getMaxThreads()
-	{
-		return _maxThreads;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Get the minimum number of threads.
-	 * Delegated to the named or anonymous Pool.
-	 * @see #setMinThreads
-	 * @return minimum number of threads.
-	 */
-	public int getMinThreads()
-	{
-		return _minThreads;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return The name of the BoundedThreadPool.
-	 */
-	public String getName()
-	{
-		return _name;
-	}
-
-	/* ------------------------------------------------------------ */
-	/** Get the priority of the pool threads.
-	 *  @return the priority of the pool threads.
-	 */
-	public int getThreadsPriority()
-	{
-		return _priority;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * Delegated to the named or anonymous Pool.
-	 */
-	public boolean isDaemon()
-	{
-		return _daemon;
-	}
-
-	/* ------------------------------------------------------------ */
-	public boolean isDetailedDump()
-	{
-		return _detailedDump;
-	}
-
-	/* ------------------------------------------------------------ */
-	public void setDetailedDump(boolean detailedDump)
-	{
-		_detailedDump = detailedDump;
-	}
-
-	/* ------------------------------------------------------------ */
-	public boolean dispatch(Runnable job)
-	{
-		if (isRunning())
-		{
-			final int jobQ = _jobs.size();
-			final int idle = getIdleThreads();
-			if(_jobs.offer(job))
-			{
-				// If we had no idle threads or the jobQ is greater than the idle threads
-				if (idle==0 || jobQ>idle)
-				{
-					int threads=_threadsStarted.get();
-					if (threads<_maxThreads)
-						startThread(threads);
-				}
-				return true;
-			}
-		}
-		LOG.debug("Dispatched {} to stopped {}",job,this);
-		return false;
-	}
-
-	/* ------------------------------------------------------------ */
-	public void execute(Runnable job)
-	{
-		if (!dispatch(job))
-			throw new RejectedExecutionException();
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * Blocks until the thread pool is {@link LifeCycle#stop stopped}.
-	 */
-	public void join() throws InterruptedException
-	{
-		synchronized (_joinLock)
-		{
-			while (isRunning())
-				_joinLock.wait();
-		}
-
-		while (isStopping())
-			Thread.sleep(1);
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return The total number of threads currently in the pool
-	 */
-	public int getThreads()
-	{
-		return _threadsStarted.get();
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return The number of idle threads in the pool
-	 */
-	public int getIdleThreads()
-	{
-		return _threadsIdle.get();
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return True if the pool is at maxThreads and there are not more idle threads than queued jobs
-	 */
-	public boolean isLowOnThreads()
-	{
-		return _threadsStarted.get()==_maxThreads && _jobs.size()>=_threadsIdle.get();
-	}
-
-	/* ------------------------------------------------------------ */
-	private boolean startThread(int threads)
-	{
-		final int next=threads+1;
-		if (!_threadsStarted.compareAndSet(threads,next))
-			return false;
-
-		boolean started=false;
-		try
-		{
-			Thread thread=newThread(_runnable);
-			thread.setDaemon(_daemon);
-			thread.setPriority(_priority);
-			thread.setName(_name+"-"+thread.getId());
-			_threads.add(thread);
-
-			thread.start();
-			started=true;
-		}
-		finally
-		{
-			if (!started)
-				_threadsStarted.decrementAndGet();
-		}
-		return started;
-	}
-
-	/* ------------------------------------------------------------ */
-	protected Thread newThread(Runnable runnable)
-	{
-		return new Thread(runnable);
-	}
-
-
-	/* ------------------------------------------------------------ */
-	public String dump()
-	{
-		return AggregateLifeCycle.dump(this);
-	}
-
-	/* ------------------------------------------------------------ */
-	public void dump(Appendable out, String indent) throws IOException
-	{
-		List<Object> dump = new ArrayList<Object>(getMaxThreads());
-		for (final Thread thread: _threads)
-		{
-			final StackTraceElement[] trace=thread.getStackTrace();
-			boolean inIdleJobPoll=false;
-			// trace can be null on early java 6 jvms
-			if (trace != null)
-			{
-				for (StackTraceElement t : trace)
-				{
-					if ("idleJobPoll".equals(t.getMethodName()))
-					{
-						inIdleJobPoll = true;
-						break;
-					}
-				}
-			}
-			final boolean idle=inIdleJobPoll;
-
-			if (_detailedDump)
-			{
-				dump.add(new Dumpable()
-				{
-					public void dump(Appendable out, String indent) throws IOException
-					{
-						out.append(String.valueOf(thread.getId())).append(' ').append(thread.getName()).append(' ').append(thread.getState().toString()).append(idle?" IDLE":"").append('\n');
-						if (!idle)
-							AggregateLifeCycle.dump(out,indent,Arrays.asList(trace));
-					}
-
-					public String dump()
-					{
-						return null;
-					}
-				});
-			}
-			else
-			{
-				dump.add(thread.getId()+" "+thread.getName()+" "+thread.getState()+" @ "+(trace.length>0?trace[0]:"???")+(idle?" IDLE":""));
-			}
-		}
-
-		AggregateLifeCycle.dumpObject(out,this);
-		AggregateLifeCycle.dump(out,indent,dump);
-
-	}
-
-
-	/* ------------------------------------------------------------ */
-	@Override
-	public String toString()
-	{
-		return _name+"{"+getMinThreads()+"<="+getIdleThreads()+"<="+getThreads()+"/"+getMaxThreads()+","+(_jobs==null?-1:_jobs.size())+"}";
-	}
-
-	/* ------------------------------------------------------------ */
-	private Runnable idleJobPoll() throws InterruptedException
-	{
-		return _jobs.poll(_maxIdleTimeMs,TimeUnit.MILLISECONDS);
-	}
-
-	/* ------------------------------------------------------------ */
-	private Runnable _runnable = new Runnable()
-	{
-		public void run()
-		{
-			boolean shrink=false;
-			try
-			{
-				Runnable job=_jobs.poll();
-				while (isRunning())
-				{
-					// Job loop
-					while (job!=null && isRunning())
-					{
-						runJob(job);
-						job=_jobs.poll();
-					}
-
-					// Idle loop
-					try
-					{
-						_threadsIdle.incrementAndGet();
-
-						while (isRunning() && job==null)
-						{
-							if (_maxIdleTimeMs<=0)
-								job=_jobs.take();
-							else
-							{
-								// maybe we should shrink?
-								final int size=_threadsStarted.get();
-								if (size>_minThreads)
-								{
-									long last=_lastShrink.get();
-									long now=System.currentTimeMillis();
-									if (last==0 || (now-last)>_maxIdleTimeMs)
-									{
-										shrink=_lastShrink.compareAndSet(last,now) &&
-										_threadsStarted.compareAndSet(size,size-1);
-										if (shrink)
-											return;
-									}
-								}
-								job=idleJobPoll();
-							}
-						}
-					}
-					finally
-					{
-						_threadsIdle.decrementAndGet();
-					}
-				}
-			}
-			catch(InterruptedException e)
-			{
-				LOG.trace("",e);
-			}
-			catch(Exception e)
-			{
-				LOG.warn("",e);
-			}
-			finally
-			{
-				if (!shrink)
-					_threadsStarted.decrementAndGet();
-				_threads.remove(Thread.currentThread());
-			}
-		}
-	};
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * <p>Runs the given job in the {@link Thread#currentThread() current thread}.</p>
-	 * <p>Subclasses may override to perform pre/post actions before/after the job is run.</p>
-	 *
-	 * @param job the job to run
-	 */
-	protected void runJob(Runnable job)
-	{
-		job.run();
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return the job queue
-	 */
-	protected BlockingQueue<Runnable> getQueue()
-	{
-		return _jobs;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @param id The thread ID to stop.
-	 * @return true if the thread was found and stopped.
-	 * @deprecated Use {@link #interruptThread(long)} in preference
-	 */
-	@Deprecated
-	public boolean stopThread(long id)
-	{
-		for (Thread thread: _threads)
-		{
-			if (thread.getId()==id)
-			{
-				thread.stop();
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @param id The thread ID to interrupt.
-	 * @return true if the thread was found and interrupted.
-	 */
-	public boolean interruptThread(long id)
-	{
-		for (Thread thread: _threads)
-		{
-			if (thread.getId()==id)
-			{
-				thread.interrupt();
-				return true;
-			}
-		}
-		return false;
-	}
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @param id The thread ID to interrupt.
-	 * @return true if the thread was found and interrupted.
-	 */
-	public String dumpThread(long id)
-	{
-		for (Thread thread: _threads)
-		{
-			if (thread.getId()==id)
-			{
-				StringBuilder buf = new StringBuilder();
-				buf.append(thread.getId()).append(" ").append(thread.getName()).append(" ").append(thread.getState()).append(":\n");
-				for (StackTraceElement element : thread.getStackTrace())
-					buf.append("  at ").append(element.toString()).append('\n');
-				return buf.toString();
-			}
-		}
-		return null;
-	}
-}
diff -r e21ca9878a10 -r 6b210bb66c63 src/org/eclipse/jetty/util/thread/ThreadPool.java
--- a/src/org/eclipse/jetty/util/thread/ThreadPool.java	Sun Oct 02 16:17:38 2016 -0600
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +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 org.eclipse.jetty.util.component.LifeCycle;
-
-/* ------------------------------------------------------------ */
-/** ThreadPool.
- * 
- *
- */
-public interface ThreadPool
-{
-	/* ------------------------------------------------------------ */
-	public abstract boolean dispatch(Runnable job);
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * Blocks until the thread pool is {@link LifeCycle#stop stopped}.
-	 */
-	public void join() throws InterruptedException;
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return The total number of threads currently in the pool
-	 */
-	public int getThreads();
-
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return The number of idle threads in the pool
-	 */
-	public int getIdleThreads();
-	
-	/* ------------------------------------------------------------ */
-	/**
-	 * @return True if the pool is low on threads
-	 */
-	public boolean isLowOnThreads();
-	
-}