repo/luan: src/org/eclipse/jetty/io/nio/SelectChannelEndPoint.java comparison

comparison src/org/eclipse/jetty/io/nio/SelectChannelEndPoint.java @ 955:6f49b8dfffe6

simplify SelectChannelEndPoint

author	Franklin Schmidt <fschmidt@gmail.com>
date	Thu, 13 Oct 2016 16:55:53 -0600
parents	7db4a488fc82
children	1094975d013b

comparison

equal deleted inserted replaced

-:a021c4c9c244
+:6f49b8dfffe6
 /* ------------------------------------------------------------ */
 /**
 * An Endpoint that can be scheduled by {@link SelectorManager}.
 */
-public class SelectChannelEndPoint extends ChannelEndPoint implements AsyncEndPoint, ConnectedEndPoint
+public final class SelectChannelEndPoint extends ChannelEndPoint implements AsyncEndPoint, ConnectedEndPoint
 {
 	public static final Logger LOG=LoggerFactory.getLogger("org.eclipse.jetty.io.nio");
 	private final SelectorManager.SelectSet _selectSet;
 	private final SelectorManager _manager;
 	private static final int STATE_NEEDS_DISPATCH = -1;
 	private static final int STATE_UNDISPATCHED = 0;
 	private static final int STATE_DISPATCHED = 1;
 	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 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 {@link SelectSet#destroyEndPoint(SelectChannelEndPoint)} has not been called */
 	private boolean _open;
-	private volatile long _idleTimestamp;
 	private volatile boolean _checkIdle;
 	private boolean _ishut;
-	/* ------------------------------------------------------------ */
 	public SelectChannelEndPoint(SocketChannel channel, SelectSet selectSet, SelectionKey key, int maxIdleTime)
 		throws IOException
 	{
 		super(channel, maxIdleTime);
 		_manager = selectSet.getManager();
 		_selectSet = selectSet;
-		_state=STATE_UNDISPATCHED;
+		_state = STATE_UNDISPATCHED;
-		_onIdle=false;
+		_open = true;
-		_open=true;
 		_key = key;
 		setCheckForIdle(true);
 	}
-	/* ------------------------------------------------------------ */
+	@Override
-	public SelectionKey getSelectionKey()
-	{
-		synchronized (this)
-		{
-			return _key;
-		}
-	}
-	public SelectorManager getSelectManager()
-	{
-		return _manager;
-	}
 	public Connection getConnection()
 	{
 		return _connection;
 	}
+	@Override
 	public void setConnection(Connection connection)
 	{
 		_connection = (AsyncConnection)connection;
 	}
 	public synchronized void schedule()
 	{
 		// If there is no key, then do nothing
 		if (_key == null || !_key.isValid())
 		{
-			_readBlocked=false;
+			_readBlocked = false;
-			_writeBlocked=false;
+			_writeBlocked = false;
 			this.notifyAll();
 			return;
 		}
 		// If there are threads dispatched reading and writing
 		{
 			// assert _dispatched;
 			if (_readBlocked && _key.isReadable())
 				_readBlocked=false;
 			if (_writeBlocked && _key.isWritable())
-				_writeBlocked=false;
+				_writeBlocked = false;
 			// wake them up is as good as a dispatched.
 			this.notifyAll();
 			// we are not interested in further selecting
 			// other wise do the dispatch
 			dispatch();
 		}
 	}
+	@Override
 	public synchronized void dispatch()
 	{
 		if (_state<=STATE_UNDISPATCHED)
 		{
-			if (_onIdle)
+			_state = STATE_DISPATCHED;
+			try {
+				_manager.execute(_handler);
+			} catch(RejectedExecutionException e) {
 				_state = STATE_NEEDS_DISPATCH;
-			else
+				LOG.warn("Dispatched Failed! "+this+" to "+_manager);
-			{
+				updateKey();
-				_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 synchronized void undispatch()
+	private synchronized void undispatch()
 	{
 		_state = STATE_UNDISPATCHED;
 		updateKey();
 	}
+	@Override
 	public void setCheckForIdle(boolean check)
 	{
 		if (check)
 		{
-			_idleTimestamp=System.currentTimeMillis();
+			_checkIdle = true;
-			_checkIdle=true;
 		}
 		else
-			_checkIdle=false;
+			_checkIdle = false;
-	}
-	private boolean isCheckForIdle()
-	{
-		return _checkIdle;
-	}
-	protected void notIdle()
-	{
-		_idleTimestamp=System.currentTimeMillis();
-	}
-	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.execute(new Runnable()
-				{
-					public void run()
-					{
-						try
-						{
-							onIdleExpired(idleForMs);
-						}
-						finally
-						{
-							setCheckForIdle(true);
-						}
-					}
-				});
-			}
-		}
-	}
-	private void onIdleExpired(long idleForMs)
-	{
-		try
-		{
-			synchronized (this)
-			{
-				_onIdle=true;
-			}
-			_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 flush(Buffer header, Buffer buffer, Buffer trailer) throws IOException
 		// 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;
+				_writable = false;
 				if (_state<STATE_DISPATCHED)
 					updateKey();
 			}
 		}
 		else if (l>0)
 		{
-			_writable=true;
+			_writable = true;
-			notIdle();
 		}
 		return l;
 	}
 	@Override
 		// 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;
+				_writable = false;
 				if (_state<STATE_DISPATCHED)
 					updateKey();
 			}
 		}
 		else if (l>0)
 		{
-			_writable=true;
+			_writable = true;
-			notIdle();
 		}
 		return l;
 	}
 		synchronized (this)
 		{
 			if (isInputShutdown())
 				throw new EofException();
+			long now = _selectSet.getNow();
+			long end = now+timeoutMs;
+			boolean check = _checkIdle;
+			setCheckForIdle(true);
+			try
+			{
+				_readBlocked = true;
+				while (!isInputShutdown() && _readBlocked)
+				{
+					try
+					{
+						updateKey();
+						this.wait(timeoutMs>0?(end-now):10000);
+					}
+					catch (final InterruptedException e)
+					{
+						LOG.warn("",e);
+					}
+					finally
+					{
+						now=_selectSet.getNow();
+					}
+					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();
 			long now=_selectSet.getNow();
 			long end=now+timeoutMs;
-			boolean check=isCheckForIdle();
+			boolean check = _checkIdle;
 			setCheckForIdle(true);
 			try
 			{
-				_readBlocked=true;
+				_writeBlocked = true;
-				while (!isInputShutdown() && _readBlocked)
+				while (_writeBlocked && !isOutputShutdown())
 				{
 					try
 					{
 						updateKey();
 						this.wait(timeoutMs>0?(end-now):10000);
 					}
 					finally
 					{
 						now=_selectSet.getNow();
 					}
-					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();
-			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);
-					}
-					finally
-					{
-						now=_selectSet.getNow();
-					}
 					if (_writeBlocked && timeoutMs>0 && now>=end)
 						return false;
 				}
 			}
 			finally
 			{
-				_writeBlocked=false;
+				_writeBlocked = false;
 				setCheckForIdle(check);
 			}
 		}
 		return true;
 	}
+	@Override
 	public boolean hasProgressed()
 	{
 		return false;
 	}
 				{
 					_key = null;
 					LOG.trace("",e);
 				}
 			}
-			changed=_interestOps!=current_ops;
+			changed = _interestOps!=current_ops;
 		}
 		if(changed)
 		{
 			doUpdateKey();
 							if (_open)
 							{
 								_selectSet.destroyEndPoint(this);
 							}
-							_open=false;
+							_open = false;
 							_key = null;
 						}
 					}
 				}
 				else
 			if (_key!=null && _key.isValid())
 				_key.cancel();
 			if (_open)
 			{
-				_open=false;
+				_open = false;
 				_selectSet.destroyEndPoint(this);
 			}
 			_key = null;
 		}
 	}
-	/* ------------------------------------------------------------ */
+	private void handle()
-	/*
-	 */
-	protected void handle()
 	{
 		boolean dispatched = true;
 		try
 		{
 			try
 		{
 			updateKey();
 		}
 	}
-	/* ------------------------------------------------------------ */
 	@Override
 	public String toString()
 	{
 		// Do NOT use synchronized (this)
 		// because it's very easy to deadlock when debugging is enabled.
 	 * @see org.eclipse.jetty.io.nio.ChannelEndPoint#setMaxIdleTime(int)
 	 */
 	@Override
 	public void setMaxIdleTime(int timeMs) throws IOException
 	{
-		_maxIdleTime=timeMs;
+		_maxIdleTime = timeMs;
 	}
 }

Mercurial Hosting > luan

comparison src/org/eclipse/jetty/io/nio/SelectChannelEndPoint.java @ 955:6f49b8dfffe6