tomcat server组件监听shutdown命令关闭服务器之源码分析

在tomcat 的server.xml文件中，顶层Server标签可以配置一个监听关闭服务器命令的端口，一旦接收到SHUTDOWN的请求后，则尝试关闭整个tomcat服务器。

具体配置如下：

<Server port="8005" shutdown="SHUTDOWN">

标识监听8005端口，如果接收到的请求为“SHUTDOWN”，那么会触发关闭服务器的操作。

为了实验这个端口好不好使，首先我把tomcat启动了起来，然后在浏览器发送了一个请求： http://localhost:8005/SHUTDOWN

结果tomcat后台日志为：

警告: StandardServer.await: Invalid command 'GET /SHUTDOWN HTTP/1.1' received

并且服务器没有关闭。这次请求收到的内容为

GET /SHUTDOWN HTTP/1.1

而不是

SHUTDOWN

，查看源码才发现，这里直接从监听的socket拿的数据，并没有做http请求解析，所以收到了一个http get请求的报文。要想正确发送SHUTDOWN，需要通过socket直接发送数据，使用jdk api的操作如下：

java.net.Socket socket = new java.net.Socket("localhost", 8005);
socket.getOutputStream().write("SHUTDOWN".getBytes());
socket.getOutputStream().flush();
socket.getOutputStream().close();
socket.close();

这样tomcat服务器就能正确关闭了，日志如下：

七月 17, 2017 12:56:59 下午 org.apache.catalina.core.StandardServer await
信息: A valid shutdown command was received via the shutdown port. Stopping the Server instance.
七月 17, 2017 12:56:59 下午 org.apache.coyote.AbstractProtocol pause
信息: Pausing ProtocolHandler ["http-bio-8080"]
七月 17, 2017 12:56:59 下午 org.apache.coyote.AbstractProtocol pause
信息: Pausing ProtocolHandler ["ajp-bio-8009"]
七月 17, 2017 12:56:59 下午 org.apache.catalina.core.StandardService stopInternal
信息: Stopping service Catalina
七月 17, 2017 12:56:59 下午 org.apache.coyote.AbstractProtocol stop
信息: Stopping ProtocolHandler ["http-bio-8080"]
七月 17, 2017 12:56:59 下午 org.apache.coyote.AbstractProtocol stop
信息: Stopping ProtocolHandler ["ajp-bio-8009"]
七月 17, 2017 12:56:59 下午 org.apache.coyote.AbstractProtocol destroy
信息: Destroying ProtocolHandler ["http-bio-8080"]
七月 17, 2017 12:56:59 下午 org.apache.coyote.AbstractProtocol destroy
信息: Destroying ProtocolHandler ["ajp-bio-8009"]

下面看一下源码的实现：

首先Bootstrap类调用了Catalina的start()方法启动服务器，在start()方法最后，有如下代码：

/**
* Catalina类
* Start a new server instance.
*/
public void start() {
...
if (await) {
await();
stop();
}
}

变量await在启动时默认为true，await()方法如下：

/**
* Catalina类
* Await and shutdown.
*/
public void await() {
getServer().await();
}

Catalina类中的Server默认实现类为StandardServer，其await()方法如下：

//StandardServer类
//简化版源码
public void await() {
//如果端口为-2或-1的处理方式

//指定了正常端口

//首先监听此端口
awaitSocket = new ServerSocket(port, 1,
InetAddress.getByName(address));
// Loop waiting for a connection and a valid command
//循环
while (!stopAwait) {
...
//阻塞在这里 等待数据
socket = serverSocket.accept();

//接收到数据后往下执行 读取数据
// Read a set of characters from the socket
int expected = 1024; // Cut off to avoid DoS attack
while (expected < shutdown.length()) {
if (random == null)
random = new Random();
expected += (random.nextInt() % 1024);
}
while (expected > 0) {
int ch = -1;
try {
ch = stream.read();
} catch (IOException e) {
log.warn("StandardServer.await: read: ", e);
ch = -1;
}
// Control character or EOF (-1) terminates loop
if (ch < 32 || ch == 127) {
break;
}
command.append((char) ch);
expected--;
}

// Match against our command string
boolean match = command.toString().equals(shutdown);
//如果接收到的请求为"SHUTDOWN"或其他正确的自定义的字符串
if (match) {
log.info(sm.getString("standardServer.shutdownViaPort"));
//跳出while循环 await()方法结束，线程执行返回到Catalina类的start()方法，继续执行Catalina的stop()方法
break;
} else
log.warn("StandardServer.await: Invalid command '"
+ command.toString() + "' received");

下面看一下Catalina的stop()方法，此方法是真正触发tomcat服务器destroy生命周期的方法：

public void stop() {
...
Server s = getServer();
LifecycleState state = s.getState();
if (LifecycleState.STOPPING_PREP.compareTo(state) <= 0
&& LifecycleState.DESTROYED.compareTo(state) >= 0) {
// Nothing to do. stop() was already called
} else {
s.stop();
s.destroy();
}
}

s即StandardServer，首先判断s的状态，该状态是一个volatile变量，如果状态为正在销毁，则不进行任何操作；否则，调用s的stop(）和destroy()方法。

stop()和destroy()方法为抽象类LifecycleBase的方法，tomcat中凡是拥有生命周期的组件均继承自此抽象类，并且这两个方法使用了 模板方法模式 ，方法内部实现了一部分更改组件状态的代码，之后调用了抽象方法stopInternal()和stopDestroy()，这俩方法的作用是留给子类去实现。

在StandardServer的stopInternal()方法中，会依次调用子组件Service的stop()方法：

@Override
protected void stopInternal() throws LifecycleException {

setState(LifecycleState.STOPPING);
fireLifecycleEvent(CONFIGURE_STOP_EVENT, null);

// Stop our defined Services
for (int i = 0; i < services.length; i++) {
services[i].stop();
}

globalNamingResources.stop();

stopAwait();
}

StandardService的stopInternal()方法如下：

protected void stopInternal() throws LifecycleException {
// Pause connectors first 首先停止connector再接收新的请求
synchronized (connectorsLock) {
for (Connector connector: connectors) {
connector.pause();
}
}
//设置状态
setState(LifecycleState.STOPPING);
// Stop our defined Container second 关闭容器，顶层为StandardEngine
if (container != null) {
synchronized (container) {
container.stop();
}
}
// Now stop the connectors 停止connector
synchronized (connectorsLock) {
for (Connector connector: connectors) {
connector.stop();
}
}
synchronized (executors) { 关闭线程池
for (Executor executor: executors) {
executor.stop();
}
}
}

之后，每层组件都是这样一步一步的向下调用，链式触发整个tomcat组件destory的生命周期，完成资源的释放和销毁，最终关闭服务器。

stop和destroy相似，只是工作不同，有兴趣的同志可以继续深入研究源码。