Tomcat7.0源代码分析——启动与停止服务原理

/**
* Initialize daemon.
*/
public void init()
throws Exception
{ // Set Catalina path
setCatalinaHome();
setCatalinaBase(); initClassLoaders(); Thread.currentThread().setContextClassLoader(catalinaLoader); SecurityClassLoad.securityClassLoad(catalinaLoader); // Load our startup class and call its process() method
if (log.isDebugEnabled())
log.debug("Loading startup class");
Class<?> startupClass =
catalinaLoader.loadClass
("org.apache.catalina.startup.Catalina");
Object startupInstance = startupClass.newInstance(); // Set the shared extensions class loader
if (log.isDebugEnabled())
log.debug("Setting startup class properties");
String methodName = "setParentClassLoader";
Class<?> paramTypes[] = new Class[1];
paramTypes[0] = Class.forName("java.lang.ClassLoader");
Object paramValues[] = new Object[1];
paramValues[0] = sharedLoader;
Method method =
startupInstance.getClass().getMethod(methodName, paramTypes);
method.invoke(startupInstance, paramValues); catalinaDaemon = startupInstance; }

/**
* 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.error("Catalina.start: ", e);
} long t2 = System.nanoTime();
if(log.isInfoEnabled())
log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms"); try {
// 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);
}
}
} catch (Throwable t) {
// This will fail on JDK 1.2. Ignoring, as Tomcat can run
// fine without the shutdown hook.
} if (await) {
await();
stop();
} }

Catalina的await方法（见代码清单8）实际仅仅是代理运行了Server容器的await方法。

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

以Server的默认实现StandardServer为例，其await方法（见代码清单9）的运行过程例如以下：

1. 创建socket连接的服务端对象ServerSocket。
2. 循环等待接收client发出的命令，假设接收到的命令与SHUTDOWN匹配（因为使用了equals，所以shutdown命令必须是大写的），那么退出循环等待。

public void await() {
// Negative values - don't wait on port - tomcat is embedded or we just don't like ports gja
if( port == -2 ) {
// undocumented yet - for embedding apps that are around, alive.
return;
}
if( port==-1 ) {
while( true ) {
try {
Thread.sleep( 10000 );
} catch( InterruptedException ex ) {
}
if( stopAwait ) return;
}
} // Set up a server socket to wait on
ServerSocket serverSocket = null;
try {
serverSocket =
new ServerSocket(port, 1,
InetAddress.getByName(address));
} catch (IOException e) {
log.error("StandardServer.await: create[" + address
+ ":" + port
+ "]: ", e);
System.exit(1);
} // Loop waiting for a connection and a valid command
while (true) { // Wait for the next connection
Socket socket = null;
InputStream stream = null;
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) {
log.error("StandardServer.await: accept: ", e);
System.exit(1);
} // Read a set of characters from the socket
StringBuilder command = new StringBuilder();
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--;
} // Close the socket now that we are done with it
try {
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"); } // Close the server socket and return
try {
serverSocket.close();
} catch (IOException e) {
// Ignore
} }

至此，Tomcat启动完成。非常多人可能会问，运行sh shutdown.sh脚本时，是怎样与Tomcat进程通信的呢？假设要与Tomcat的ServerSocket通信。socketclient怎样知道服务端的连接地址与端口呢？以下会慢慢说明。

sh shutdown.sh

所以，将从shell脚本shutdown.sh開始分析Tomcat的停止过程。shutdown.sh的脚本代码见代码清单10。

os400=false
case "`uname`" in
OS400*) os400=true;;
esac# resolve links - $0 may be a softlink
PRG="$0"while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`/"$link"
fi
donePRGDIR=`dirname "$PRG"`
EXECUTABLE=catalina.sh# Check that target executable exists
if $os400; then
# -x will Only work on the os400 if the files are:
# 1. owned by the user
# 2. owned by the PRIMARY group of the user
# this will not work if the user belongs in secondary groups
eval
else
if [ ! -x "$PRGDIR"/"$EXECUTABLE" ]; then
echo "Cannot find $PRGDIR/$EXECUTABLE"
echo "The file is absent or does not have execute permission"
echo "This file is needed to run this program"
exit 1
fi
fiexec "$PRGDIR"/"$EXECUTABLE" stop "$@"

代码清单10和代码清单1非常类似。当中也有两个基本的变量，各自是：

• PRGDIR：当前shell脚本所在的路径；
• EXECUTABLE：脚本catalina.sh。

依据最后一行代码：exec "$PRGDIR"/"$EXECUTABLE" stop "$@"，我们知道运行了shell脚本catalina.sh，而且传递參数stop。catalina.sh中接收到stop參数后的运行的脚本分支见代码清单11。

elif [ "$1" = "stop" ] ; then #省略參数校验脚本 eval "\"$_RUNJAVA\"" $LOGGING_MANAGER $JAVA_OPTS \
-Djava.endorsed.dirs="\"$JAVA_ENDORSED_DIRS\"" -classpath "\"$CLASSPATH\"" \
-Dcatalina.base="\"$CATALINA_BASE\"" \
-Dcatalina.home="\"$CATALINA_HOME\"" \
-Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
org.apache.catalina.startup.Bootstrap "$@" stop

从代码清单11能够看出，终于使用java命令运行了org.apache.catalina.startup.Bootstrap类中的main方法，參数是stop。从代码清单3能够看出，当传递參数stop的时候，command等于stop，此时main方法的运行过程例如以下：

/**
* Stop the standalone server.
*/
public void stopServer(String[] arguments)
throws Exception { Object param[];
Class<?> paramTypes[];
if (arguments==null || arguments.length==0) {
paramTypes = null;
param = null;
} else {
paramTypes = new Class[1];
paramTypes[0] = arguments.getClass();
param = new Object[1];
param[0] = arguments;
}
Method method =
catalinaDaemon.getClass().getMethod("stopServer", paramTypes);
method.invoke(catalinaDaemon, param); }

Catalina的stopServer方法（见代码清单13）的运行过程例如以下：

1. 创建Digester解析server.xml文件（此处仅仅解析标签），以构造出Server容器（此时Server容器的子容器没有被实例化）；
2. 从实例化的Server容器获取Server的socket监听端口和地址。然后创建Socket对象连接启动Tomcat时创建的ServerSocket，最后向ServerSocket发送SHUTDOWN命令。依据代码清单9的内容，ServerSocket循环等待接收到SHUTDOWN命令后，终于调用stop方法停止Tomcat。

public void stopServer() {
stopServer(null);
} public void stopServer(String[] arguments) { if (arguments != null) {
arguments(arguments);
} if( getServer() == null ) {
// Create and execute our Digester
Digester digester = createStopDigester();
digester.setClassLoader(Thread.currentThread().getContextClassLoader());
File file = configFile();
try {
InputSource is =
new InputSource("file://" + file.getAbsolutePath());
FileInputStream fis = new FileInputStream(file);
is.setByteStream(fis);
digester.push(this);
digester.parse(is);
fis.close();
} catch (Exception e) {
log.error("Catalina.stop: ", e);
System.exit(1);
}
} // Stop the existing server
try {
if (getServer().getPort()>0) {
Socket socket = new Socket(getServer().getAddress(),
getServer().getPort());
OutputStream stream = socket.getOutputStream();
String shutdown = getServer().getShutdown();
for (int i = 0; i < shutdown.length(); i++)
stream.write(shutdown.charAt(i));
stream.flush();
stream.close();
socket.close();
} else {
log.error(sm.getString("catalina.stopServer"));
System.exit(1);
}
} catch (IOException e) {
log.error("Catalina.stop: ", e);
System.exit(1);
} }

最后，我们看看Catalina的stop方法（见代码清单14）的实现，其运行过程例如以下：

1. 将启动过程中加入的关闭钩子移除。

   Tomcat启动过程辛辛苦苦加入的关闭钩子为什么又要去掉呢？因为关闭钩子是为了在JVM异常退出后，进行资源的回收工作。主动停止Tomcat时调用的stop方法里已经包括了资源回收的内容，所以不再须要这个钩子了。

2. 停止Server容器。

   有关容器的停止内容。请阅读《Tomcat7.0源代码分析——生命周期管理》一文。

/**
* Stop an existing server instance.
*/
public void stop() { try {
// Remove the ShutdownHook first so that server.stop()
// doesn't get invoked twice
if (useShutdownHook) {
Runtime.getRuntime().removeShutdownHook(shutdownHook); // If JULI is being used, re-enable JULI's shutdown to ensure
// log messages are not lost jiaan
LogManager logManager = LogManager.getLogManager();
if (logManager instanceof ClassLoaderLogManager) {
((ClassLoaderLogManager) logManager).setUseShutdownHook(
true);
}
}
} catch (Throwable t) {
// This will fail on JDK 1.2. Ignoring, as Tomcat can run
// fine without the shutdown hook.
} // Shut down the server
try {
getServer().stop();
} catch (LifecycleException e) {
log.error("Catalina.stop", e);
} }

总结

后记：个人总结整理的《深入理解Spark：核心思想与源代码分析》一书如今已经正式出版上市，眼下京东、当当、天猫等站点均有销售。欢迎感兴趣的同学购买。

京东：http://item.jd.com/11846120.html 

当当：http://product.dangdang.com/23838168.html