io.netty.handler.timeout.IdleStateHandler功能是监测Channel上read, write或者这两者的空闲状态。当Channel超过了指定的空闲时间时，这个Handler会触发一个IdleStateEvent事件。
在第一次检测到Channel变成active状态时向EventExecutor中提交三个延迟任务：
ReaderIdleTimeoutTask: 检测read空闲超时。
WriterIdleTimeoutTask: 检测write空闲超时。
AllIdleTimeoutTask: 检测所有的空闲超时。
任何一个延迟任务检测到空闲超时是会触发一个IdleStateEvent。无论如何，延迟任务都会再次把自己提交到EventExecutor中，等待下次执行。
三个延迟任务对应于三个超时时间，都是可以独立设置的:
1 public IdleStateHandler(boolean observeOutput, 2 long readerIdleTime, long writerIdleTime, long allIdleTime, 3 TimeUnit unit) { 4 if (unit == null) { 5 throw new NullPointerException("unit"); 6 } 7 8 this.observeOutput = observeOutput; 9 10 if (readerIdleTime <= 0) {11 readerIdleTimeNanos = 0;12 } else {13 readerIdleTimeNanos = Math.max(unit.toNanos(readerIdleTime), MIN_TIMEOUT_NANOS);14 }15 if (writerIdleTime <= 0) {16 writerIdleTimeNanos = 0;17 } else {18 writerIdleTimeNanos = Math.max(unit.toNanos(writerIdleTime), MIN_TIMEOUT_NANOS);19 }20 if (allIdleTime <= 0) {21 allIdleTimeNanos = 0;22 } else {23 allIdleTimeNanos = Math.max(unit.toNanos(allIdleTime), MIN_TIMEOUT_NANOS);24 }25 }
这个类继承自io.netty.channel.ChannelDuplexHandler, 它是一个有状态的ChannelHandler, 定义了三个状态:
private byte state; // 0 - none, 1 - initialized, 2 - destroyed
state属性保存了它的状态。0：初始状态，1：已经初始化， 2: 已经销毁。
这个ChannelHandler被加入到Channel的pipeline中之后，在Channel已经被register到EventLoop中，且处于Active状态时，会执行一次初始化操作，向EventExecutor提交前面提到的三个延迟任务。这初始化操作在initialize方法中实现。
1 private void initialize(ChannelHandlerContext ctx) { 2 // Avoid the case where destroy() is called before scheduling timeouts. 3 // See: https://github.com/netty/netty/issues/143 4 switch (state) { 5 case 1: 6 case 2: 7 return; 8 } 9 10 state = 1;11 initOutputChanged(ctx);12 13 lastReadTime = lastWriteTime = ticksInNanos();14 if (readerIdleTimeNanos > 0) {15 readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),16 readerIdleTimeNanos, TimeUnit.NANOSECONDS);17 }18 if (writerIdleTimeNanos > 0) {19 writerIdleTimeout = schedule(ctx, new WriterIdleTimeoutTask(ctx),20 writerIdleTimeNanos, TimeUnit.NANOSECONDS);21 }22 if (allIdleTimeNanos > 0) {23 allIdleTimeout = schedule(ctx, new AllIdleTimeoutTask(ctx),24 allIdleTimeNanos, TimeUnit.NANOSECONDS);25 }26 }
第4-10行，只有处于初始状态时才执行后面的操作，避免多次提交定时任务。
第11行， 初始化对对Channel的outboundBuffer变化的监视，只有当observeOutput属性设置为true时才开启这个监视。
第13-25行，分别提交三个延迟任务。
initialize方法可能在三个地方被调用:
@Override public void handlerAdded(ChannelHandlerContext ctx) throws Exception { if (ctx.channel().isActive() && ctx.channel().isRegistered()) { // channelActive() event has been fired already, which means this.channelActive() will // not be invoked. We have to initialize here instead. initialize(ctx);
} else { // channelActive() event has not been fired yet. this.channelActive() will be invoked // and initialization will occur there. }
}
@Override public void channelRegistered(ChannelHandlerContext ctx) throws Exception { // Initialize early if channel is active already.
if (ctx.channel().isActive()) {
initialize(ctx);
} super.channelRegistered(ctx);
}
@Override public void channelActive(ChannelHandlerContext ctx) throws Exception { // This method will be invoked only if this handler was added // before channelActive() event is fired. If a user adds this handler // after the channelActive() event, initialize() will be called by beforeAdd(). initialize(ctx); super.channelActive(ctx);
}
如果在Channel初始化的时候把这个Handler添加到pipeline中，那么这个Handler的channelActive方法一定会被调用，只需要在channleActive中调用initialize就可以打了。但是Handler可以在任何时候被加入到pipleline中。当ChannelHandler被添加到pipeline中时，Channel可能已经被register到EventLoop中，且已经处于Active状态，这种情况下，channelRegistered和channelActive方法都不会被调用，所以必须在handlerAdded中调用initialize。如果此时，Channnel已经处于Active状态，但还没被注册到EventLoop，只能在channelRegisted中调用initialize。
初始化完成之后，延迟任务到期执行时会把自己再次提交到EventExecutor中，等待下次执行。同时会检查是否满足触发事件的条件，如果是就触发一条自定义的事件。
read空闲超时检查
1 private final class ReaderIdleTimeoutTask extends AbstractIdleTask { 2 @Override 3 protected void run(ChannelHandlerContext ctx) { 4 long nextDelay = readerIdleTimeNanos; 5 if (!reading) { 6 nextDelay -= ticksInNanos() - lastReadTime; 7 } 8 9 if (nextDelay <= 0) {10 // Reader is idle - set a new timeout and notify the callback.11 readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);12 13 boolean first = firstReaderIdleEvent;14 firstReaderIdleEvent = false;15 16 try {17 IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);18 channelIdle(ctx, event);19 } catch (Throwable t) {20 ctx.fireExceptionCaught(t);21 }22 } else {23 // Read occurred before the timeout - set a new timeout with shorter delay.24 readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);25 }26 }27 }
4-9行，判断是否read空闲超时。
11-21行，read空闲超时，重新把自己提交成延迟任务。
24行，read没有空闲超时，重新把自己提交成延迟任务。
这里的关键是判断read空闲超时。lastReadTime是最近一次执行read的时间，readerIdleTimeNanos是初始化时设置的空闲超时时间，因此如果readerIdleTimeNanos - （ticksInNanos() - lastReadtime) <= 0，表示已经read空闲超时了。令人困惑的是第5行，只有在reading==false才检查进行空闲超时的计算。笔者在<
1 @Override 2 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { 3 if (readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) { 4 reading = true; 5 firstReaderIdleEvent = firstAllIdleEvent = true; 6 } 7 ctx.fireChannelRead(msg); 8 } 9 10 @Override11 public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {12 if ((readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) && reading) {13 lastReadTime = ticksInNanos();14 reading = false;15 }16 ctx.fireChannelReadComplete();17 }
3-4行，在设置了读空闲超时或所有空闲超时的情况下，会吧reading设置成true，表示当前正处于正在read的状态。
12-14行，在设置了读空闲超时或所有空闲超时的情况下， 如果当前正处于read状态，把reading设置成false，同时更新最近一次执行read的时间。
write空闲超时检查
1 private final class WriterIdleTimeoutTask extends AbstractIdleTask { 2 3 @Override 4 protected void run(ChannelHandlerContext ctx) { 5 6 long lastWriteTime = IdleStateHandler.this.lastWriteTime; 7 long nextDelay = writerIdleTimeNanos - (ticksInNanos() - lastWriteTime); 8 if (nextDelay <= 0) { 9 // Writer is idle - set a new timeout and notify the callback.10 writerIdleTimeout = schedule(ctx, this, writerIdleTimeNanos, TimeUnit.NANOSECONDS);11 12 boolean first = firstWriterIdleEvent;13 firstWriterIdleEvent = false;14 15 try {16 if (hasOutputChanged(ctx, first)) {17 return;18 }19 20 IdleStateEvent event = newIdleStateEvent(IdleState.WRITER_IDLE, first);21 channelIdle(ctx, event);22 } catch (Throwable t) {23 ctx.fireExceptionCaught(t);24 }25 } else {26 // Write occurred before the timeout - set a new timeout with shorter delay.27 writerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);28 }29 }30 }
6-8行，检查write空闲超时，和检查read空闲超时类似。
12-21行，如果write空闲超时，且outboundBuffer中的数据没有变化, 触发write空闲超时事件。
这里调用了hasOutputChanged方法检查outboundBuffer中的数据是否有变化。笔者在<
AllIdleTimeoutTask的实现和WriterIdleTimeoutTask类似，只不过检查超时的条件有些差别：read和write任何一个空闲超时都算超时。
ReadTimeoutHandler实现
ReadTimeoutHandler继承了IdleStateHandler类，它的功能是在触发read空闲超时事件时触发一个ReadTimeoutException异常，同时关闭Channel。
@Override protected final void channelIdle(ChannelHandlerContext ctx, IdleStateEvent evt) throws Exception { assert evt.state() == IdleState.READER_IDLE;
readTimedOut(ctx);
} /**
* Is called when a read timeout was detected. */
protected void readTimedOut(ChannelHandlerContext ctx) throws Exception { if (!closed) {
ctx.fireExceptionCaught(ReadTimeoutException.INSTANCE);
ctx.close();
closed = true;
}
}
WriteTimeoutHandler实现
WriteTimeoutHandler继承了ChannelOutboundHandlerAdapter，它的功能是在触发监视Channel的write调用超时，如果超时则关闭掉这个Channel。和ReadTimeoutHandler不同，它监控的不是空闲超时，而是Channel的write方法返回的Promise超时。
首先在write时候，为每个Promise添加一个监控超时的延迟任务: 郑州妇科医院:http://jbk.39.net/yiyuanzaixian/sysdfkyy/郑州人流医院×××:http://jbk.39.net/yiyuanzaixian/sysdfkyy/郑州做×××多少钱:http://jbk.39.net/yiyuanzaixian/sysdfkyy/
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
scheduleTimeout(ctx, promise);
ctx.write(msg, promise);
} private void scheduleTimeout(final ChannelHandlerContext ctx, final ChannelPromise promise) { // Schedule a timeout.
final WriteTimeoutTask task = new WriteTimeoutTask(ctx, promise);
task.scheduledFuture = ctx.executor().schedule(task, timeoutNanos, TimeUnit.NANOSECONDS); if (!task.scheduledFuture.isDone()) {
addWriteTimeoutTask(task); // Cancel the scheduled timeout if the flush promise is complete. promise.addListener(task);
}
}
然后，如果延迟任务执行的时候检查到Promise超时，就触发一个WriteTimeoutException异常，然后关闭掉这个Channel。
protected void writeTimedOut(ChannelHandlerContext ctx) throws Exception { if (!closed) {
ctx.fireExceptionCaught(WriteTimeoutException.INSTANCE);
ctx.close();
closed = true;
}
}
WriteTimeoutTask类同时实现了Runnable和ChannelFutureListener接口，超时后会调用run方法。
1 @Override 2 public void run() { 3 // Was not written yet so issue a write timeout 4 // The promise itself will be failed with a ClosedChannelException once the close() was issued 5 // See https://github.com/netty/netty/issues/2159 6 if (!promise.isDone()) { 7 try { 8 writeTimedOut(ctx); 9 } catch (Throwable t) {10 ctx.fireExceptionCaught(t);11 }12 }13 removeWriteTimeoutTask(this);14 }
7-10行，promise没有完成，触发WriteTimeoutException或其他异常。
13行，write已经完成，删除当前的WriteTimeoutTask对象。
如果promise已经完成, 会调用operationComplete方法, 清理掉当前的WriteTimeoutTask对象。
@Override public void operationComplete(ChannelFuture future) throws Exception { // scheduledFuture has already be set when reaching here
scheduledFuture.cancel(false);
removeWriteTimeoutTask(this);
}