Poller的主要逻辑也是while循环直到关闭，循环内部主要分三个部分
- 处理events跟关闭逻辑
- 处理IO事件
- 处理socket timeout
public void run() {
// Loop until destroy() is called
while (true) {
boolean hasEvents = false;
try {
// 1、处理events跟关闭逻辑
if (!close) {
hasEvents = events();
if (wakeupCounter.getAndSet(-1) > 0) {
// If we are here, means we have other stuff to do
// Do a non blocking select
keyCount = selector.selectNow();
} else {
keyCount = selector.select(selectorTimeout);
}
wakeupCounter.set(0);
}
if (close) {
events();
timeout(0, false);
try {
selector.close();
} catch (IOException ioe) {
log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
}
break;
}
if (keyCount == 0) {
hasEvents = (hasEvents | events());
}
} catch (Throwable x) {
ExceptionUtils.handleThrowable(x);
log.error(sm.getString("endpoint.nio.selectorLoopError"), x);
continue;
}
// 2、处理IO事件
Iterator<SelectionKey> iterator =
keyCount > 0 ? selector.selectedKeys().iterator() : null;
// Walk through the collection of ready keys and dispatch
// any active event.
while (iterator != null && iterator.hasNext()) {
SelectionKey sk = iterator.next();
iterator.remove();
NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
// Attachment may be null if another thread has called
// cancelledKey()
if (socketWrapper != null) {
processKey(sk, socketWrapper);
}
}
// 3、处理socket timeout
timeout(keyCount,hasEvents);
}
getStopLatch().countDown();
}
events跟关闭逻辑处理
为什么要有events？
Poller外部可能会希望修改socket感兴趣的事件，比如Acceptor需要将socket注册到selector上，比如Poller获取到一个读就绪的socket时，需要先取消监听读就绪事件，然后交给Processor去处理，如果Processor处理完只会还需要继续监听读就绪事件 （没有读到一个完整的http包，或者keep-alive）。但是如果Poller阻塞在selector#select方法上调用socket#register的话，register方法也会阻塞住。所以就设计一个事件机制，当外部需要修改socket感兴趣事件，就提交一个event到poller，由poller来修改socket感兴趣事件
events就是一个普通的队列，跟java的SynchronousQueue完全不是一个东西，SynchronizedQueue是tomcat实现的一个线程安全的队列
private final SynchronizedQueue<PollerEvent> events =
new SynchronizedQueue<>();
外部线程将事件提交到events队列，怎么确保事件及时处理？
Poller线程selector.select(selectorTimeout)默认超时是1秒钟，如果socket注册事件要延迟一秒执行肯定是不可忍受的。外部线程跟Poller线程通过wakeupCounter配合使得事件能够尽快执行。wakeupCounter初始值是0，表示没有外部线程添加了event；-1表示poller正在阻塞select中，如果外部线程添加event时发现poller在阻塞，需要唤醒poller
// Poller线程进入阻塞select时，会将wakeupCounter设置为-1
// 外部线程添加event时，将wakeupCounter加1。加到0表示poller正在阻塞，需要唤醒poller（selectNow过程中也是-1，尽管这时候不需要唤醒，但是唤醒也没有什么问题）
private void addEvent(PollerEvent event) {
events.offer(event);
if (wakeupCounter.incrementAndGet() == 0) {
selector.wakeup();
}
}
Poller里面的逻辑
if (!close) {
// 第一步，大循环首先会处理event
hasEvents = events();
// 第二步，这里将wakeupCounter设置为-1，进入select。如果原先的值大于0，表示有线程添加事件，进入selectNow，线程下一轮循环处理event
// 否则阻塞select
// 如果这一步getAndSet > 0，一定意味着有event要处理吗？并不是，可能第一步就处理完了。但不要紧，目的是确保不能有event等着不能被处理
// 如果getAndSet == 0，就一定意味着没有event要处理，可以放心阻塞的select
if (wakeupCounter.getAndSet(-1) > 0) {
keyCount = selector.selectNow();
} else {
keyCount = selector.select(selectorTimeout);
}
// 第三步，退出select，将wakeupCounter设置为0。因为poller并没有阻塞，不需要外部线程来唤醒
wakeupCounter.set(0);
}
if (close) {
events();
timeout(0, false);
try {
selector.close();
} catch (IOException ioe) {
log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
}
break;
}
// 这里是当没有IO就绪事件时，尽早处理下event。也无关紧要
if (keyCount == 0) {
hasEvents = (hasEvents | events());
}
} catch (Throwable x) {
ExceptionUtils.handleThrowable(x);
log.error(sm.getString("endpoint.nio.selectorLoopError"), x);
continue;
}
处理IO事件
主要有三个事情的处理
1、处理文件发送
2、处理读写事件
3、处理socket关闭
protected void processKey(SelectionKey sk, NioSocketWrapper socketWrapper) {
try {
if (close) {
cancelledKey(sk, socketWrapper);
} else if (sk.isValid()) {
if (sk.isReadable() || sk.isWritable()) {
if (socketWrapper.getSendfileData() != null) {
// 发送文件的处理
processSendfile(sk, socketWrapper, false);
} else {
// 先取消监听就绪的事件
unreg(sk, socketWrapper, sk.readyOps());
boolean closeSocket = false;
// 先处理读
if (sk.isReadable()) {
if (socketWrapper.readOperation != null) {
if (!socketWrapper.readOperation.process()) {
closeSocket = true;
}
} else if (socketWrapper.readBlocking) {
synchronized (socketWrapper.readLock) {
socketWrapper.readBlocking = false;
socketWrapper.readLock.notify();
}
} else if (!processSocket(socketWrapper, SocketEvent.OPEN_READ, true)) {
closeSocket = true;
}
}
// 后处理写
if (!closeSocket && sk.isWritable()) {
if (socketWrapper.writeOperation != null) {
if (!socketWrapper.writeOperation.process()) {
closeSocket = true;
}
} else if (socketWrapper.writeBlocking) {
synchronized (socketWrapper.writeLock) {
socketWrapper.writeBlocking = false;
socketWrapper.writeLock.notify();
}
} else if (!processSocket(socketWrapper, SocketEvent.OPEN_WRITE, true)) {
closeSocket = true;
}
}
// 如果需要关闭socket，这里关闭掉socket
if (closeSocket) {
cancelledKey(sk, socketWrapper);
}
}
}
} else {
cancelledKey(sk, socketWrapper);
}
} catch (CancelledKeyException ckx) {
cancelledKey(sk, socketWrapper);
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
log.error(sm.getString("endpoint.nio.keyProcessingError"), t);
}
}
processSocket方法会创建SocketProcessor，然后提交到线程池中处理。Poller本身不处理socket数据
public boolean processSocket(SocketWrapperBase<S> socketWrapper,
SocketEvent event, boolean dispatch) {
try {
if (socketWrapper == null) {
return false;
}
SocketProcessorBase<S> sc = null;
if (processorCache != null) {
sc = processorCache.pop();
}
if (sc == null) {
sc = createSocketProcessor(socketWrapper, event);
} else {
sc.reset(socketWrapper, event);
}
Executor executor = getExecutor();
if (dispatch && executor != null) {
executor.execute(sc);
} else {
sc.run();
}
} catch (RejectedExecutionException ree) {
getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);
return false;
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
// This means we got an OOM or similar creating a thread, or that
// the pool and its queue are full
getLog().error(sm.getString("endpoint.process.fail"), t);
return false;
}
return true;
}
timeout处理
protected void timeout(int keyCount, boolean hasEvents) {
long now = System.currentTimeMillis();
if (nextExpiration > 0 && (keyCount > 0 || hasEvents) && (now < nextExpiration) && !close) {
return;
}
int keycount = 0;
try {
for (SelectionKey key : selector.keys()) {
keycount++;
NioSocketWrapper socketWrapper = (NioSocketWrapper) key.attachment();
try {
if (socketWrapper == null) {
cancelledKey(key, null);
} else if (close) {
// 如果poller关闭了，那么key也会取消注册IO事件
key.interestOps(0);
socketWrapper.interestOps(0);
cancelledKey(key, socketWrapper);
} else if (socketWrapper.interestOpsHas(SelectionKey.OP_READ) ||
socketWrapper.interestOpsHas(SelectionKey.OP_WRITE)) {
boolean readTimeout = false;
boolean writeTimeout = false;
// 计算是否读数据超时了
if (socketWrapper.interestOpsHas(SelectionKey.OP_READ)) {
long delta = now - socketWrapper.getLastRead();
long timeout = socketWrapper.getReadTimeout();
if (timeout > 0 && delta > timeout) {
readTimeout = true;
}
}
// 计算是否写数据超时了
if (!readTimeout && socketWrapper.interestOpsHas(SelectionKey.OP_WRITE)) {
long delta = now - socketWrapper.getLastWrite();
long timeout = socketWrapper.getWriteTimeout();
if (timeout > 0 && delta > timeout) {
writeTimeout = true;
}
}
// 读超时或者写超时，都会移除这个key
if (readTimeout || writeTimeout) {
key.interestOps(0);
socketWrapper.interestOps(0);
socketWrapper.setError(new SocketTimeoutException());
if (readTimeout && socketWrapper.readOperation != null) {
if (!socketWrapper.readOperation.process()) {
cancelledKey(key, socketWrapper);
}
} else if (writeTimeout && socketWrapper.writeOperation != null) {
if (!socketWrapper.writeOperation.process()) {
cancelledKey(key, socketWrapper);
}
} else if (!processSocket(socketWrapper, SocketEvent.ERROR, true)) {
cancelledKey(key, socketWrapper);
}
}
}
} catch (CancelledKeyException ckx) {
cancelledKey(key, socketWrapper);
}
}
} catch (ConcurrentModificationException cme) {
// See https://bz.apache.org/bugzilla/show_bug.cgi?id=57943
log.warn(sm.getString("endpoint.nio.timeoutCme"), cme);
}
}
}
1545
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
