之前的几篇文章讲了Tomcat的启动过程，在默认的配置下启动完之后会看到后台实际上总共有6个线程在运行。即1个用户线程，剩下5个为守护线程(下图中的Daemon Thread)。
如果你对什么叫守护线程的概念比较陌生，这里再重复一下：
所谓守护线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程。这种线程并不属于程序中不可或缺的部分，当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程。反过来说，只要任何非守护线程还在运行，程序就不会终止。
用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了。将线程转换为守护线程可以通过调用Thread对象的setDaemon(true)方法来实现。
Tomcat的关闭正是利用了这个原理，即只要将那唯一的一个用户线程关闭，则整个应用就关闭了。
要研究这个用户线程怎么被关闭的得先从这个线程从何产生说起。在前面分析Tomcat的启动时我们是从org.apache.catalina.startup.Bootstrap类的main方法作为入口，该类的453到456行是Tomcat启动时会执行的代码：
前面的文章里分析了daemon.load和daemon.start方法，这里请注意daemon.setAwait(true);这句，它的作用是通过反射调用org.apache.catalina.startup.Catalina类的setAwait(true)方法，最终将Catalina类的实例变量await设值为true。
Catalina类的setAwait方法代码：
/**
* Set flag.
*/
public void setAwait(boolean await)
throws Exception {
Class<?> paramTypes[] = new Class[1];
paramTypes[0] = Boolean.TYPE;
Object paramValues[] = new Object[1];
paramValues[0] = Boolean.valueOf(await);
Method method =
catalinaDaemon.getClass().getMethod("setAwait", paramTypes);
method.invoke(catalinaDaemon, paramValues);
}
如前文分析，Tomcat启动时会调用org.apache.catalina.startup.Catalina类的start方法，看下这个方法的代码：
/**
* Start a new server instance.
*/
public void start() {
if (getServer() == null) {
load();
}
if (getServer() == null) {
log.fatal("Cannot start server. Server instance is not configured.");
return;
}
long t1 = System.nanoTime();
// Start the new server
try {
getServer().start();
} catch (LifecycleException e) {
log.fatal(sm.getString("catalina.serverStartFail"), e);
try {
getServer().destroy();
} catch (LifecycleException e1) {
log.debug("destroy() failed for failed Server ", e1);
}
return;
}
long t2 = System.nanoTime();
if(log.isInfoEnabled()) {
log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
}
// Register shutdown hook
if (useShutdownHook) {
if (shutdownHook == null) {
shutdownHook = new CatalinaShutdownHook();
}
Runtime.getRuntime().addShutdownHook(shutdownHook);
// If JULI is being used, disable JULI's shutdown hook since
// shutdown hooks run in parallel and log messages may be lost
// if JULI's hook completes before the CatalinaShutdownHook()
LogManager logManager = LogManager.getLogManager();
if (logManager instanceof ClassLoaderLogManager) {
((ClassLoaderLogManager) logManager).setUseShutdownHook(
false);
}
}
if (await) {
await();
stop();
}
}
前文分析启动时发现通过第19行getServer().start()的这次方法调用，Tomcat接下来会一步步启动所有在配置文件中配置的组件。后面的代码没有分析，这里请关注最后第52到55行，上面说到已经将Catalina类的实例变量await设值为true，所以这里将会执行Catalina类的await方法：
/**
* Await and shutdown.
*/
public void await() {
getServer().await();
}
该方法就一句话，意思是调用org.apache.catalina.core.StandardServer类的await方法：
/**
* Wait until a proper shutdown command is received, then return.
* This keeps the main thread alive - the thread pool listening for http
* connections is daemon threads.
*/
@Override
public void await() {
// Negative values - don't wait on port - tomcat is embedded or we just don't like ports
if( port == -2 ) {
// undocumented yet - for embedding apps that are around, alive.
return;
}
if( port==-1 ) {
try {
awaitThread = Thread.currentThread();
while(!stopAwait) {
try {
Thread.sleep( 10000 );
} catch( InterruptedException ex ) {
// continue and check the flag
}
}
} finally {
awaitThread = null;
}
return;
}
// Set up a server socket to wait on
try {
awaitSocket = new ServerSocket(port, 1,
InetAddress.getByName(address));
} catch (IOException e) {
log.error("StandardServer.await: create[" + address
+ ":" + port
+ "]: ", e);
return;
}
try {
awaitThread = Thread.currentThread();
// Loop waiting for a connection and a valid command
while (!stopAwait) {
ServerSocket serverSocket = awaitSocket;
if (serverSocket == null) {
break;
}
// Wait for the next connection
Socket socket = null;
StringBuilder command = new StringBuilder();
try {
InputStream stream;
try {
socket = serverSocket.accept();
socket.setSoTimeout(10 * 1000); // Ten seconds
stream = socket.getInputStream();
} catch (AccessControlException ace) {
log.warn("StandardServer.accept security exception: "
+ ace.getMessage(), ace);
continue;
} catch (IOException e) {
if (stopAwait) {
// Wait was aborted with socket.close()
break;
}
log.error("StandardServer.await: accept: ", e);
break;
}
// 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;
}
if (ch < 32) // Control character or EOF terminates loop
break;
command.append((char) ch);
expected--;
}
} finally {
// Close the socket now that we are done with it
try {
if (socket != null) {
socket.close();
}
} catch (IOException e) {
// Ignore
}
}
// Match against our command string
boolean match = command.toString().equals(shutdown);
if (match) {
log.info(sm.getString("standardServer.shutdownViaPort"));
break;
} else
log.warn("StandardServer.await: Invalid command '"
+ command.toString() + "' received");
}
} finally {
ServerSocket serverSocket = awaitSocket;
awaitThread = null;
awaitSocket = null;
// Close the server socket and return
if (serverSocket != null) {
try {
serverSocket.close();
} catch (IOException e) {
// Ignore
}
}
}
}
这段代码就不一一分析，总体作用如方法前的注释所说，即“一直等待到接收到一个正确的关闭命令后该方法将会返回。这样会使主线程一直存活——监听http连接的线程池是守护线程”。
熟悉Java的Socket编程的话对这段代码就很容易理解，就是默认地址（地址值由实例变量address定义，默认为localhost）的默认的端口（端口值由实例变量port定义，默认为8005）上监听Socket连接，当发现监听到的连接的输入流中的内容与默认配置的值匹配（该值默认为字符串SHUTDOWN）则跳出循环，该方法返回（第103到107行）。否则该方法会一直循环执行下去。
一般来说该用户主线程会阻塞（第56行）直到有访问localhost:8005的连接出现。
正因为如此才出现开头看见的主线程一直Running的情况，而因为这个线程一直Running，其它守护线程也会一直存在。
说完这个线程的产生，接下来看看这个线程的关闭，按照上面的分析，这个线程提供了一个关闭机制，即只要访问localhost:8005，并且发送一个内容为SHUTDOWN的字符串，就可以关闭它了。
Tomcat正是这么做的，一般来说关闭Tomcat通过执行shutdown.bat或shutdown.sh脚本，关于这段脚本可参照
分析启动脚本那篇文章，机制类似，最终会执行org.apache.catalina.startup.Bootstrap类的main方法，并传入入参"stop"，看下本文第2张图片中org.apache.catalina.startup.Bootstrap类的第458行，接着将调用org.apache.catalina.startup.Catalina类stopServer方法：
public void stopServer(String[] arguments) {
if (arguments != null) {
arguments(arguments);
}
Server s = getServer();
if( s == null ) {
// Create and execute our Digester
Digester digester = createStopDigester();
digester.setClassLoader(Thread.currentThread().getContextClassLoader());
File file = configFile();
FileInputStream fis = null;
try {
InputSource is =
new InputSource(file.toURI().toURL().toString());
fis = new FileInputStream(file);
is.setByteStream(fis);
digester.push(this);
digester.parse(is);
} catch (Exception e) {
log.error("Catalina.stop: ", e);
System.exit(1);
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
// Ignore
}
}
}
} else {
// Server object already present. Must be running as a service
try {
s.stop();
} catch (LifecycleException e) {
log.error("Catalina.stop: ", e);
}
return;
}
// Stop the existing server
s = getServer();
if (s.getPort()>0) {
Socket socket = null;
OutputStream stream = null;
try {
socket = new Socket(s.getAddress(), s.getPort());
stream = socket.getOutputStream();
String shutdown = s.getShutdown();
for (int i = 0; i < shutdown.length(); i++) {
stream.write(shutdown.charAt(i));
}
stream.flush();
} catch (ConnectException ce) {
log.error(sm.getString("catalina.stopServer.connectException",
s.getAddress(),
String.valueOf(s.getPort())));
log.error("Catalina.stop: ", ce);
System.exit(1);
} catch (IOException e) {
log.error("Catalina.stop: ", e);
System.exit(1);
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
// Ignore
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
// Ignore
}
}
}
} else {
log.error(sm.getString("catalina.stopServer"));
System.exit(1);
}
}
第8到41行是读取配置文件，可参照前面
分析Digester的文章，不再赘述。从第49行开始，即向localhost:8005发起一个Socket连接，并写入SHUTDOWN字符串。
这样将会关闭Tomcat中的那唯一的一个用户线程，接着所有守护线程将会退出（由JVM保证），之后整个应用关闭。
以上分析Tomcat的默认关闭机制，但这是通过运行脚本来关闭，我觉得这样比较麻烦，那么能不能通过一种在线访问的方式关闭Tomcat呢？当然可以，比较暴力的玩法是直接改org.apache.catalina.core.StandardServer的源码第500行，将
boolean match = command.toString().equals(shutdown);
改成
boolean match = command.toString().equals(“GET /SHUTDOWN HTTP/1.1”);
或者修改server.xml文件，找到Server节点，将原来的
<Server port="8005" shutdown="SHUTDOWN">
改成
<Server port="8005" shutdown="GET /SHUTDOWN HTTP/1.1">
这样直接在浏览器中输入http://localhost:8005/SHUTDOWN就可以关闭Tomcat了，原理？看懂了上面的文章，这个应该不难。
分享到：
相关推荐
├─5.03 tomcat目录介绍-tomcat运维-启动与关闭.mp4 ├─5.04 tomcat运维-tomcat日志说明-tomcat管理功能.mp4 ├─5.05 tomcat运维-server.xml配置文件注释.mp4 ├─5.06 tomcat运维-web站点部署.mp4 ├─5.07 ...
《深入剖析Tomcat》深入剖析Tomcat 4和Tomcat 5中的每个组件(如果TOMCAT版本有点老，不过现在的Tomcat6和7同样可以借鉴参考)，并揭示其内部工作原理。通过学习《深入剖析Tomcat》，你将可以自行开发Tomcat组件，或者...
TomcatMoni(TOMCAT监控助手）此程序用于运行在服务器中，预留在内存中，监控网站是否可以正常打开。 原理即间隔性的访问指定的服务器中运行的网站，如果能够打开就正常，打不开就执行重启命令 使用前，请修改conf....
-Tomcat的工作原理开发自己的Java Servlet容器的指南 章节 第三章连接器 第四章Tomcat的默认连接器 第五章servlet容器 第六章生命周期 第七章日志记录器 第八章加载器 第九章会议管理 第十章应用程序 第十一章...
1.3.5 配置和测试Tomcat服务器 1.4 JSP与数据库建立连接 1.4.1 JSP连接MySQL数据库 1.4.2 JSP连接SQL Server数据库 1.4.3 JSP连接Oracle数据库 1.4.4 JSP连接DB2数据库 1.4.5 指点迷津——连接...
短连接是指：请求响应一次，服务器就关闭与浏览器之间的网络连接。 无状态是指，任意两次请求响应之间，没有直接的联系。 浏览器发出一个请求，服务器才能返回一个响应。一个请求对应一个响应，每个过程都是完全...
1.1.2. 在Tomcat 服务器上运行示例.......................................................................................................................... 15 1.1.3. 运行测试..............................
6.2.3 MyEclipse中集成Tomcat服务器 85 6.3 使用MyEclipse开发Web应用程序 86 6.3.1 创建Web项目 87 6.3.2 创建HTML静态页面 88 6.3.3 创建JSP页面 90 6.3.4 创建Servlet 91 6.3.5 创建Web项目中的Java类文件 92 ...
4.5.3 服务器端推送技术 106 4.6 Spring MVC 的测试 113 4.6.1 点睛 113 4.6.2 示例 114 第三部分 实战Spring Boot 第5 章 Spring Boot 基础 122 5.1 Spring Boot 概述 122 5.1.1 什么是Spring Boot 122 5.1.2 ...
4.5.3 服务器端推送技术 106 4.6 Spring MVC 的测试 113 4.6.1 点睛 113 4.6.2 示例 114 第三部分 实战Spring Boot 第5 章 Spring Boot 基础 122 5.1 Spring Boot 概述 122 5.1.1 什么是Spring Boot 122 5.1.2 ...
4.5.3 服务器端推送技术 106 4.6 Spring MVC 的测试 113 4.6.1 点睛 113 4.6.2 示例 114 第三部分 实战Spring Boot 第5 章 Spring Boot 基础 122 5.1 Spring Boot 概述 122 5.1.1 什么是Spring Boot 122 5.1.2 ...
4.1.1 安装应用服务器Tomcat 104 4.1.2 安装Eclipse中的Tomcat插件 108 4.1.3 安装Eclipse中的Lomboz插件 110 4.2 基本JSP程序的开发 112 案例4-1 实现Java Web页面的登录验证 113 4.3 JSP＋JavaBean两层...
基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式的聊天软件,用socket实现,比较简单。 ...
基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式的聊天软件,用socket实现,比较简单。 ...
2.3.1 Tomcat的安装及系统文件设置 2.3.2 WebSphere简介 2.3.3 WebLogic的安装和配置 2.3.4 Resin的安装与配置 2.4 Java开发环境 2.4.1 JDK设置 2.4.2 JBuilder的配置 2.4.3 Cafe的配置 2.4.4 JDeveloper的...
14.4.6响应窗口关闭事件处理示例454 14.4.7事件监听器接口和适配器类456 14.4.8作为参数的事件类456 14.4.9处理多个事件的例子463 14.5Swing组件的特性467 14.5.1Swing组件的优势467 14.5.2Swing组件的体系...
2.3.2安装Tomcat服务器 18 2.3.3Tomcat集成RED5服务器 20 2.4安装VisualBasic6.0 22 2.5小结 23 第3章ActionScript3.0语法 24 3.1变量 24 3.1.1变量声明 24 3.1.2变量赋值 25 3.1.3变量的生存周期 26 3.2基本数据...
但通常情况下，由于Java Bean是被容器所创建（如Tomcat）的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地...
7：关闭SessionFactory Hibernate持久化：Hibernate根据定义的映射规则将对象持久化保存到数据库，这就实现了对象的持久化。 Spring由那几个模块组成? 答：Spring主要由7个模块组成： 1：Spring核心容器：提供了...