Tomcat探秘（5）：tomcat关闭过程详述

迈不过友情╰ 2022-08-23 08:46 311阅读 0赞

在上一篇文章中，我们对tomcat的启动过程进行了简单的说明，在这篇文章中将对关闭过程进行简单的说明。

关闭tomcat一般我们都是采用的是：

./shutdown.sh

我们打开这个脚本文件，看看里面的具体实现：

# -----------------------------------------------------------------------------
    # Stop script for the CATALINA Server
    # -----------------------------------------------------------------------------
    
    # Better OS/400 detection: see Bugzilla 31132
    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
    done
    
    PRGDIR=`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
    fi
    
    exec "$PRGDIR"/"$EXECUTABLE" stop "$@"

从上面可以看出，其实和启动脚本没什么区别，最终调用的都是catalina.sh，只是传递给catalina.sh的参数不一样，之前传递的是start，而这里传递的是stop，仅此而已。而catalina.sh在接收到stop参数后，会进入到相应的条件分支：

............
    elif [ "$1" = "stop" ] ; then
    
      shift
    
      SLEEP=5
      if [ ! -z "$1" ]; then
        echo $1 | grep "[^0-9]" >/dev/null 2>&1
        if [ $? -gt 0 ]; then
          SLEEP=$1
          shift
        fi
      fi
    
      FORCE=0
      if [ "$1" = "-force" ]; then
        shift
        FORCE=1
      fi
    
      if [ ! -z "$CATALINA_PID" ]; then
        if [ -f "$CATALINA_PID" ]; then
          if [ -s "$CATALINA_PID" ]; then
            kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
            if [ $? -gt 0 ]; then
              echo "PID file found but no matching process was found. Stop aborted."
              exit 1
            fi
          else
            echo "PID file is empty and has been ignored."
          fi
        else
          echo "\$CATALINA_PID was set but the specified file does not exist. Is Tomcat running? Stop aborted."
          exit 1
        fi
      fi
    
      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
    
      # stop failed. Shutdown port disabled? Try a normal kill.
      if [ $? != 0 ]; then
        if [ ! -z "$CATALINA_PID" ]; then
          echo "The stop command failed. Attempting to signal the process to stop through OS signal."
          kill -15 `cat "$CATALINA_PID"` >/dev/null 2>&1
        fi
      fi
    
      if [ ! -z "$CATALINA_PID" ]; then
        if [ -f "$CATALINA_PID" ]; then
          while [ $SLEEP -ge 0 ]; do
            kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
            if [ $? -gt 0 ]; then
              rm -f "$CATALINA_PID" >/dev/null 2>&1
              if [ $? != 0 ]; then
                if [ -w "$CATALINA_PID" ]; then
                  cat /dev/null > "$CATALINA_PID"
                  # If Tomcat has stopped don't try and force a stop with an empty PID file
                  FORCE=0
                else
                  echo "The PID file could not be removed or cleared."
                fi
              fi
              echo "Tomcat stopped."
              break
            fi
            if [ $SLEEP -gt 0 ]; then
              sleep 1
            fi
            if [ $SLEEP -eq 0 ]; then
              echo "Tomcat did not stop in time."
              if [ $FORCE -eq 0 ]; then
                echo "PID file was not removed."
              fi
              echo "To aid diagnostics a thread dump has been written to standard out."
              kill -3 `cat "$CATALINA_PID"`
            fi
            SLEEP=`expr $SLEEP - 1 `
          done
        fi
      fi
    
      KILL_SLEEP_INTERVAL=5
      if [ $FORCE -eq 1 ]; then
        if [ -z "$CATALINA_PID" ]; then
          echo "Kill failed: \$CATALINA_PID not set"
        else
          if [ -f "$CATALINA_PID" ]; then
            PID=`cat "$CATALINA_PID"`
            echo "Killing Tomcat with the PID: $PID"
            kill -9 $PID
            while [ $KILL_SLEEP_INTERVAL -ge 0 ]; do
                kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1
                if [ $? -gt 0 ]; then
                    rm -f "$CATALINA_PID" >/dev/null 2>&1
                    if [ $? != 0 ]; then
                        if [ -w "$CATALINA_PID" ]; then
                            cat /dev/null > "$CATALINA_PID"
                        else
                            echo "The PID file could not be removed."
                        fi
                    fi
                    echo "The Tomcat process has been killed."
                    break
                fi
                if [ $KILL_SLEEP_INTERVAL -gt 0 ]; then
                    sleep 1
                fi
                KILL_SLEEP_INTERVAL=`expr $KILL_SLEEP_INTERVAL - 1 `
            done
            if [ $KILL_SLEEP_INTERVAL -lt 0 ]; then
                echo "Tomcat has not been killed completely yet. The process might be waiting on some system call or might be UNINTERRUPTIBLE."
            fi
          fi
        fi
      fi
    
    elif ......

从上面的脚本中可以看到，最终执行的是

org.apache.catalina.startup.Bootstrap "$@" stop

也就是调用了Bootstrap类，并且传递了stop方法，我们下面看看这个类又是怎么处理这个传入参数的：

在main方法中发现有这么一段：

} else if (command.equals("stop")) {
                    daemon.stopServer(args);
                }

所以，其实是调用了Bootstrap类的stopServer(args)方法，但是在上面这段代码之前其实还有一个过程，跟启动过程一样先判断Bootstrap类有没有初始化，如果没有则进行初始化，具体过程可以参看上一篇文章。下面直接从 stopServer(args)开始说起。

/**
         * 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);
    
        }

从代码看，应该是调用了catalinaDaemon对象（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();
                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);
            }
        }

从上面的代码可以看出，大概过程应该是这样的：判断是否有Server对象，如果没有则像tomcat启动一样创建一个Degister去解析server.xml文件获取相关启动的端口配置信息等，然后根据解析到的配置，向指定的启动端口创建Socket连接并发送一个SHUTDOWN的命令（启动服务的时候，从上一篇文章可以看出其实tomcat一直在监听指定端口，随时接收用户发送的SHUTDOWN命令），从而起到关闭tomcat服务的目的，最后释放各种资源；如果一开始判断就有了Server对象，则直接调用Server对象（标准实现为StandardServer）的stop方法关闭服务。

接下来，我们看看stop方法：

/**
         * 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
                    LogManager logManager = LogManager.getLogManager();
                    if (logManager instanceof ClassLoaderLogManager) {
                        ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                                true);
                    }
                }
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                // This will fail on JDK 1.2. Ignoring, as Tomcat can run
                // fine without the shutdown hook.
            }
    
            // Shut down the server
            try {
                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();
                }
            } catch (LifecycleException e) {
                log.error("Catalina.stop", e);
            }
    
        }

从代码看出，首先主动移除了tomcat初始化过程中创建的关闭钩子，因为关闭钩子主要是考虑到异常情况下退出时释放资源，而在这里主动关闭服务已经可以正常的进行释放资源了，为了避免两次释放，所以首先移除了关闭钩子。紧接着，判断当前服务组件Server的状态，如何符合关闭的条件，则进行服务的关闭和资源释放工作。

至此，整个tomcat的启动和关闭服务的业务逻辑我们简单的说明了一下，至于其中的细节将在后面细说，谢谢。