【resin】 resin3 线程池与IO模型（2）
上篇文章主要介绍了resin3的线程池逻辑，下面具体分析下resin3的网络IO模型
resin3开源版使用的IO模型是BIO模型
相关的核心类是Port和TcpConnection
下面贴出源码：为说明核心逻辑，只展示核心的代码
本文所分析为个人理解，欢迎指出不足之处或分享你的观点
下面看看 Port 类：
/**
* The port thread is responsible for creating new connections.
*
* 负责创建 tcp connection task的主线程
*/
public
void
run()
{
while
(!
_lifecycle
.isDestroyed()) {
boolean
isStart;
try
{
// Thread.sleep(10);
synchronized
(
this
) {
// need delay to avoid spawning too many threads over a short time,
// when the load doesn't justify it
if
(
_idleThreadCount
> 0) {
wait(1);
}
/**
* port 线程创建 tcp connection task的条件有三个：
* 1.lifecycle.isActive() 为true 这个应该是只要resin服务没有停止就肯定是true了
* 2.isStart = _startThreadCount + _idleThreadCount < _acceptThreadMin 第二个条件是这个 isStart 为true
* _acceptThreadMin 是用户设置的最小创建来accept socket的线程数
* _idleThreadCount 这个可以理解为当前block在 accept的线程数，相当于等待，就是idle了
* _startThreadCount 这个值的作用，我的理解是主要用来控制创建 tcp accept的task数量， 防止无限制的创建
*
* 3._connectionMax <= _connectionCount 这个条件基本上可以忽略了，resin默认的最大链接数是 1024*1024 这个够用了
*
*/
isStart =
_startThreadCount
+
_idleThreadCount
<
_acceptThreadMin
;
if
(
_connectionMax
<=
_connectionCount
)
isStart =
false
;
if
(!
_lifecycle
.isActive())
isStart =
false
;
/**
* 如果不需要创建新的 connection 则port线程就等待 1 分钟
*/
if
(! isStart) {
Thread. interrupted();
wait(60000);
}
if
(isStart) {
_connectionCount
++;
_startThreadCount
++;
}
}
if
(isStart &&
_lifecycle
.isActive()) {
TcpConnection conn =
_freeConn
.allocate();
if
(conn ==
null
) {
conn =
new
TcpConnection(
this
,
_serverSocket
.createSocket());
conn.setRequest(
_protocol
.createRequest(conn));
}
conn.start();
/**
* 创建完 tcp connection task 是 Runnable 的
* 丢进resin的线程池里执行
*/
ThreadPool. getThreadPool().schedule (conn);
}
}
catch
(Throwable e) {
e.printStackTrace();
}
}
}
// port 线程在resin IO处理逻辑中起着关键作用，而且是单线程执行
// port 线程的逻辑很简单，就是不断轮询，只要满足条件就创建 TcpConnection task 提交线程池处理
// 不满足条件就 wait 60秒
//
下面看看 TcpConnection
tcpconnection task的run方法很长，我直接省略了很多代码，保留核心逻辑
/**
* Runs as a task.
*/
public
void
run ()
{
Port port = getPort();
boolean
isKeepalive =
_isKeepalive
;
_isKeepalive
=
false
;
boolean
isResume =
_isResume
;
_isResume
=
false
;
_isWake
=
false
;
boolean
isFirst = ! isKeepalive;
ServerRequest request = getRequest();
boolean
isWaitForRead = request.isWaitForRead();
if
(isKeepalive)
port.keepaliveEnd(
this
);
/**
* tcp connection task 的主要任务就是 accept 等待新的的链接
*/
while
(!
_isDead
) {
if
(isKeepalive) {
}
/**
* accept 在等待
*/
else
if
(port.accept(
this
, isFirst))
_connectionStartTime
= Alarm. getCurrentTime();
else
return
;
isFirst =
false
;
ConnectionController controller =
null
;
try
{
do
{
controller =
null
;
isKeepalive =
false
;
if
(! port.isClosed()
&& (! isWaitForRead || getReadStream().waitForRead())) {
/**
* accept 之后，这里处理 http request了
*/
synchronized
(
_requestLock
) {
isKeepalive = request.handleRequest();
}
controller = getController();
if
(controller !=
null
&& controller.isActive()) {
isKeepalive =
true
;
return
;
}
}
}
while
(isKeepalive && waitForKeepalive() && ! port.isClosed());
if
(isKeepalive) {
return
;
}
else
{
getRequest().protocolCloseEvent();
}
}
catch
(ClientDisconnectException e) {
}
catch
(IOException e) {
}
finally
{
if
(! isKeepalive)
closeImpl();
}
}
}
catch
(Throwable e) {
}
finally
{
/**
* 任务执行完了，这个 tcp task就结束了
*/
if
(isKeepalive) {
keepalive();
}
else
free();
}
}
// 可以看到 tcp connection task如果是keepalive的，会一直轮询，等待处理http请求
// 整个task 执行流程是：
// 首先执行Port的accept方法，等待tcp链接，port.accept(
this
, isFirst)
// 创建完链接后，就会去处理这个http请求
request.handleRequest();
// 整个处理流程包含了 tcp链接创建和http请求处理
去看下Port的accept方法
/**
* Accepts a new connection.
*/
public
boolean
accept (TcpConnection conn,
boolean
isFirst)
{
try
{
synchronized
(
this
) {
_idleThreadCount
++;
/**
* _startThreadCount 在这里进行了
--
自减操作
*/
if
(isFirst) {
_startThreadCount--;
}
if
(
_acceptThreadMax
<
_idleThreadCount
) {
return
false
;
}
}
while
(
_lifecycle
.isActive()) {
QSocket socket = conn.startSocket();
/**
* 这里将会调用底层 jdk的accept 方法
*/
if
(
_serverSocket
.accept(socket)) {
conn.initSocket();
if
(
_throttle
.accept(socket))
return
true
;
else
socket.close();
}
else
{
if
(
_acceptThreadMax
<
_idleThreadCount
) {
return
false
;
}
}
}
}
catch
(Throwable e) {
}
finally
{
synchronized
(
this
) {
_idleThreadCount
--;
if
(
_idleThreadCount
+
_startThreadCount
<
_acceptThreadMin
) {
notify();
}
}
}
return
false
;
}
// 可以看到 Port类的 accept方法是同步方法块
// 整个方法的逻辑也简单
//
我们的一个线上服务用的是resin3的开源版，一直都运行良好
但是每当流量暴涨时，resin就是出现假死的情况，进行多番排查，基本定位问题了
下面给出分析：
主要是 Port 线程的逻辑 和 resin参数配置的问题
在 Port 线程逻辑里，创建 tcp connection task有3个条件 ：起关键影响的是这个
/**
* 着重讲讲这个条件 isStart = _startThreadCount + _idleThreadCount < _acceptThreadMin;
*
* _acceptThreadMin resin默认值为5
* _acceptThreadMax resin默认值为10
*
* 当resin服务的外部流量稳定时，即平滑增长状态，则 port线程运行的很良好
* 但是当出现流量暴涨时，而且resin的线程池已经耗尽，已经达到 threadMax，此时会出现问题
* _idleThreadCount 一直为0，threadCount 也没有呈现增长的状态，外部链接出现了响应超时情况，感觉是resin服务“挂了”
*
* 推测这个时候的状态是这样的：
* 1.虽然 _idleThreadCount 为0，但是 _startThreadCount 增长到 _acceptThreadMin了
* 即 isStart = _acceptThreadMin + 0 < _acceptThreadMin ； isStart 为 false
* _startThreadCount 要减少的情况就是 新创建的 tcp connection task开始执行accept了
*
* 2.此时已经有 最多threadMax 的线程在执行，时间片分配得花点时间了
* 考虑极端情况，新创建的 _startThreadCount（值已经等于_acceptThreadMin）个线程都在等待时间片分配
* 另外， tcp connection task要开始执行accept，还得要先获得 port 线程对象的锁
* synchronized (this) {
* 省略代码。。。
* if (isFirst) {
* _startThreadCount
--
;
* }
* 省略代码。。。
* }
*
* 3.既然 isStart 为 false 则 port 线程就会进行等待 wait(60000) 足足等待一分钟，而且 port线程只有一个
* 如果后续 isStart 还不为 true ，则就还会继续等待 60 秒，这将会是灾难了
*
* 4.结合了上述的情况，外部的链接就没有办法得到响应了，只能等当前的请求都处理完，才能进行处理后续的请求了
*
* PS：我曾经试着去掉 _startThreadCount 这个条件进行了测试，程序没跑多久就出现 OOM等的问题了
* 明显，这个_startThreadCount 是限制创建 tcp task的数量，因为 resin的线程池里的task队列是无界的，用的是 ArrayList
<Runnable>
*
*
* 要避免这样的情况：就把 _acceptThreadMin _acceptThreadMax 分别设置的大些
* 防止 port线程因为 isStart条件的问题导致无法分配 tcp accept的线程，从而导致无法响应更多的外部请求
*
* 开源版resin是BIO线程池模型，是阻塞的，即创建一定量的 accept thread，等待请求并处理
* resin的并发能力取决于 accept thread的线程数 与 最大 threadMax
*
* 专业版resin貌似是使用 nio，通过select机制，效率吞吐量都会更好
*
*/
扫一扫
2096
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
