Tomcat源码分析 （六）----- Tomcat 启动过程(一)

说到tomcat的启动，我们都知道，我们每次需要运行tomcat/bin/startup.sh这个脚本，而这个脚本的内容到底是什么呢？我们来看看。

启动脚本

startup.sh 脚本

#!/bin/sh
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" start "$@"

我们来看看这脚本。该脚本中有2个重要的变量：

1. prgdir：表示当前脚本所在的路径
2. executable：catalina.sh 脚本名称
   其中最关键的一行代码就是 exec "$prgdir"/"$executable" start "$@"，表示执行了脚本catalina.sh，参数是start。

catalina.sh 脚本

然后我们看看catalina.sh 脚本中的实现：

elif [ "$1" = "start" ] ; then

  if [ ! -z "$catalina_pid" ]; then
    if [ -f "$catalina_pid" ]; then
      if [ -s "$catalina_pid" ]; then
        echo "existing pid file found during start."
        if [ -r "$catalina_pid" ]; then
          pid=`cat "$catalina_pid"`
          ps -p $pid >/dev/null 2>&1
          if [ $? -eq 0 ] ; then
            echo "tomcat appears to still be running with pid $pid. start aborted."
            echo "if the following process is not a tomcat process, remove the pid file and try again:"
            ps -f -p $pid
            exit 1
          else
            echo "removing/clearing stale pid file."
            rm -f "$catalina_pid" >/dev/null 2>&1
            if [ $? != 0 ]; then
              if [ -w "$catalina_pid" ]; then
                cat /dev/null > "$catalina_pid"
              else
                echo "unable to remove or clear stale pid file. start aborted."
                exit 1
              fi
            fi
          fi
        else
          echo "unable to read pid file. start aborted."
          exit 1
        fi
      else
        rm -f "$catalina_pid" >/dev/null 2>&1
        if [ $? != 0 ]; then
          if [ ! -w "$catalina_pid" ]; then
            echo "unable to remove or write to empty pid file. start aborted."
            exit 1
          fi
        fi
      fi
    fi
  fi

  shift
  touch "$catalina_out"
  if [ "$1" = "-security" ] ; then
    if [ $have_tty -eq 1 ]; then
      echo "using security manager"
    fi
    shift
    eval $_nohup "\"$_runjava\"" "\"$logging_config\"" $logging_manager $java_opts $catalina_opts \
      -classpath "\"$classpath\"" \
      -djava.security.manager \
      -djava.security.policy=="\"$catalina_base/conf/catalina.policy\"" \
      -dcatalina.base="\"$catalina_base\"" \
      -dcatalina.home="\"$catalina_home\"" \
      -djava.io.tmpdir="\"$catalina_tmpdir\"" \
      org.apache.catalina.startup.bootstrap "$@" start \
      >> "$catalina_out" 2>&1 "&"

  else
    eval $_nohup "\"$_runjava\"" "\"$logging_config\"" $logging_manager $java_opts $catalina_opts \
      -classpath "\"$classpath\"" \
      -dcatalina.base="\"$catalina_base\"" \
      -dcatalina.home="\"$catalina_home\"" \
      -djava.io.tmpdir="\"$catalina_tmpdir\"" \
      org.apache.catalina.startup.bootstrap "$@" start \
      >> "$catalina_out" 2>&1 "&"

  fi

  if [ ! -z "$catalina_pid" ]; then
    echo $! > "$catalina_pid"
  fi

  echo "tomcat started."

该脚本很长，但我们只关心我们感兴趣的：如果参数是 start， 那么执行这里的逻辑，关键再最后一行执行了 org.apache.catalina.startup.bootstrap "$@" start， 也就是说，执行了我们熟悉的main方法，并且携带了start 参数，那么我们就来看bootstrap 的main方法是如何实现的。

bootstrap.main

首先我们启动 main 方法:

public static void main(string args[]) {
    system.err.println("have fun and enjoy! cxs");

    // daemon 就是 bootstrap
    if (daemon == null) {
        bootstrap bootstrap = new bootstrap();
        try {
            //类加载机制我们前面已经讲过，在这里就不在重复了
            bootstrap.init();
        } catch (throwable t) {
            handlethrowable(t);
            t.printstacktrace();
            return;
        }
        daemon = bootstrap;
    } else {
        thread.currentthread().setcontextclassloader(daemon.catalinaloader);
    }
    try {
        // 命令
        string command = "start";
        // 如果命令行中输入了参数
        if (args.length > 0) {
            // 命令 = 最后一个命令
            command = args[args.length - 1];
        }
        // 如果命令是启动
        if (command.equals("startd")) {
            args[args.length - 1] = "start";
            daemon.load(args);
            daemon.start();
        }
        // 如果命令是停止了
        else if (command.equals("stopd")) {
            args[args.length - 1] = "stop";
            daemon.stop();
        }
        // 如果命令是启动
        else if (command.equals("start")) {
            daemon.setawait(true);// bootstrap 和 catalina 一脉相连, 这里设置, 方法内部设置 catalina 实例setawait方法
            daemon.load(args);// args 为 空,方法内部调用 catalina 的 load 方法.
            daemon.start();// 相同, 反射调用 catalina 的 start 方法 ,至此,启动结束
        } else if (command.equals("stop")) {
            daemon.stopserver(args);
        } else if (command.equals("configtest")) {
            daemon.load(args);
            if (null==daemon.getserver()) {
                system.exit(1);
            }
            system.exit(0);
        } else {
            log.warn("bootstrap: command \"" + command + "\" does not exist.");
        }
    } catch (throwable t) {
        // unwrap the exception for clearer error reporting
        if (t instanceof invocationtargetexception &&
                t.getcause() != null) {
            t = t.getcause();
        }
        handlethrowable(t);
        t.printstacktrace();
        system.exit(1);
    }
}

我们来看看bootstrap.init();的部分代码

public void init() throws exception {

    // 类加载机制我们前面已经讲过，在这里就不在重复了
    initclassloaders();

    thread.currentthread().setcontextclassloader(catalinaloader);
    securityclassload.securityclassload(catalinaloader);

    // 反射方法实例化catalina
    class<?> startupclass = catalinaloader.loadclass("org.apache.catalina.startup.catalina");
    object startupinstance = startupclass.getconstructor().newinstance();

   
    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);

    // 引用catalina实例
    catalinadaemon = startupinstance;
}

我们可以看到是通过反射实例化catalina类，并将实例引用赋值给catalinadaemon,接着我们看看daemon.load(args);

private void load(string[] arguments)
    throws exception {

    // call the load() method
    string methodname = "load";
    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(methodname, paramtypes);
    if (log.isdebugenabled())
        log.debug("calling startup class " + method);
    //通过反射调用catalina的load()方法
    method.invoke(catalinadaemon, param);

}

catalina.load

我们可以看到daemon.load(args)实际上就是通过反射调用catalina的load()方法.那么我们进入 catalina 类的 load 方法看看:

public void load() {

    initdirs();

    // 初始化jmx的环境变量
    initnaming();

    // create and execute our digester
    // 定义解析server.xml的配置，告诉digester哪个xml标签应该解析成什么类
    digester digester = createstartdigester();

    inputsource inputsource = null;
    inputstream inputstream = null;
    file file = null;
    try {

      // 首先尝试加载conf/server.xml，省略部分代码......
      // 如果不存在conf/server.xml，则加载server-embed.xml(该xml在catalina.jar中)，省略部分代码......
      // 如果还是加载不到xml，则直接return，省略部分代码......

      try {
          inputsource.setbytestream(inputstream);

          // 把catalina作为一个*实例
          digester.push(this);

          // 解析过程会实例化各个组件，比如server、container、connector等
          digester.parse(inputsource);
      } catch (saxparseexception spe) {
          // 处理异常......
      }
    } finally {
        // 关闭io流......
    }

    // 给server设置catalina信息
    getserver().setcatalina(this);
    getserver().setcatalinahome(bootstrap.getcatalinahomefile());
    getserver().setcatalinabase(bootstrap.getcatalinabasefile());

    // stream redirection
    initstreams();

    // 调用lifecycle的init阶段
    try {
        getserver().init();
    } catch (lifecycleexception e) {
        // ......
    }

    // ......

}

server初始化

可以看到, 这里有一个我们今天感兴趣的方法, getserver.init(), 这个方法看名字是启动 server 的初始化, 而 server 是我们上面图中最外层的容器. 因此, 我们去看看该方法, 也就是lifecyclebase.init() 方法. 该方法是一个模板方法, 只是定义了一个算法的骨架, 将一些细节算法放在子类中去实现.我们看看该方法:

lifecyclebase.init()

@override
public final synchronized void init() throws lifecycleexception {
    // 1
    if (!state.equals(lifecyclestate.new)) {
        invalidtransition(lifecycle.before_init_event);
    }
    // 2
    setstateinternal(lifecyclestate.initializing, null, false);

    try {
        // 模板方法
        /**
         * 采用模板方法模式来对所有支持生命周期管理的组件的生命周期各个阶段进行了总体管理，
         * 每个需要生命周期管理的组件只需要继承这个基类，
         * 然后覆盖对应的钩子方法即可完成相应的声明周期阶段的管理工作
         */
        initinternal();
    } catch (throwable t) {
        exceptionutils.handlethrowable(t);
        setstateinternal(lifecyclestate.failed, null, false);
        throw new lifecycleexception(
                sm.getstring("lifecyclebase.initfail",tostring()), t);
    }

    // 3
    setstateinternal(lifecyclestate.initialized, null, false);
}

server的实现类为standardserver，我们分析一下standardserver.initinternal()方法。该方法用于对server进行初始化，关键的地方就是代码最后对services的循环操作，对每个service调用init方法。
【注】：这儿我们只粘贴出这部分代码。

standardserver.initinternal()

@override
protected void initinternal() throws lifecycleexception {
    super.initinternal();

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

调用service子容器的init方法，让service组件完成初始化，注意：在同一个server下面，可能存在多个service组件.

service初始化

standardservice和standardserver都是继承至lifecyclembeanbase，因此公共的初始化逻辑都是一样的，这里不做过多介绍，我们直接看下initinternal

standardservice.initinternal()

protected void initinternal() throws lifecycleexception {

    // 往jmx中注册自己
    super.initinternal();

    // 初始化engine
    if (engine != null) {
        engine.init();
    }

    // 存在executor线程池，则进行初始化，默认是没有的
    for (executor executor : findexecutors()) {
        if (executor instanceof jmxenabled) {
            ((jmxenabled) executor).setdomain(getdomain());
        }
        executor.init();
    }

    mapperlistener.init();

    // 初始化connector，而connector又会对protocolhandler进行初始化，开启应用端口的监听,
    synchronized (connectorslock) {
        for (connector connector : connectors) {
            try {
                connector.init();
            } catch (exception e) {
                // 省略部分代码，logger and throw exception
            }
        }
    }
}

1. 首先，往jmx中注册standardservice
2. 初始化engine，而engine初始化过程中会去初始化realm(权限相关的组件)
3. 如果存在executor线程池，还会进行init操作，这个excecutor是tomcat的接口，继承至java.util.concurrent.executor、org.apache.catalina.lifecycle
4. 初始化connector连接器，默认有http1.1、ajp连接器，而这个connector初始化过程，又会对protocolhandler进行初始化，开启应用端口的监听，后面会详细分析

engine初始化

standardengine初始化的代码如下：

@override
protected void initinternal() throws lifecycleexception {
    getrealm();
    super.initinternal();
}

public realm getrealm() {
    realm configured = super.getrealm();
    if (configured == null) {
        configured = new nullrealm();
        this.setrealm(configured);
    }
    return configured;
}

standardengine继承至containerbase，而containerbase重写了initinternal()方法，用于初始化start、stop线程池，这个线程池有以下特点：
1. core线程和max是相等的，默认为1
2. 允许core线程在超时未获取到任务时退出线程
3. 线程获取任务的超时时间是10s，也就是说所有的线程(包括core线程)，超过10s未获取到任务，那么这个线程就会被销毁

这么做的初衷是什么呢？因为这个线程池只需要在容器启动和停止的时候发挥作用，没必要时时刻刻处理任务队列

containerbase的代码如下所示：

// 默认是1个线程
private int startstopthreads = 1;
protected threadpoolexecutor startstopexecutor;

@override
protected void initinternal() throws lifecycleexception {
    blockingqueue<runnable> startstopqueue = new linkedblockingqueue<>();
    startstopexecutor = new threadpoolexecutor(
            getstartstopthreadsinternal(),
            getstartstopthreadsinternal(), 10, timeunit.seconds,
            startstopqueue,
            new startstopthreadfactory(getname() + "-startstop-"));
    // 允许core线程超时未获取任务时退出
    startstopexecutor.allowcorethreadtimeout(true);
    super.initinternal();
}

private int getstartstopthreadsinternal() {
    int result = getstartstopthreads();

    if (result > 0) {
        return result;
    }
    result = runtime.getruntime().availableprocessors() + result;
    if (result < 1) {
        result = 1;
    }
    return result;
}

这个startstopexecutor线程池有什么用呢？

1. 在start的时候，如果发现有子容器，则会把子容器的start操作放在线程池中进行处理
2. 在stop的时候，也会把stop操作放在线程池中处理

在前面的文章中我们介绍了container组件，standardengine作为顶层容器，它的直接子容器是stardandhost，但是对standardengine的代码分析，我们并没有发现它会对子容器stardandhost进行初始化操作，standardengine不按照套路出牌，而是把初始化过程放在start阶段。个人认为host、context、wrapper这些容器和具体的webapp应用相关联了，初始化过程会更加耗时，因此在start阶段用多线程完成初始化以及start生命周期，否则，像顶层的server、service等组件需要等待host、context、wrapper完成初始化才能结束初始化流程，整个初始化过程是具有传递性的

connector初始化

connector初始化会在后面有专门的connector文章讲解

总结

至此，整个初始化过程便告一段落。整个初始化过程，由parent组件控制child组件的初始化，一层层往下传递，直到最后全部初始化ok。下图描述了整体的传递流程 

默认情况下，server只有一个service组件，service组件先后对engine、connector进行初始化。而engine组件并不会在初始化阶段对子容器进行初始化，host、context、wrapper容器的初始化是在start阶段完成的。tomcat默认会启用http1.1和ajp的connector连接器，这两种协议默认使用http11nioprotocol、ajpnioprotocol进行处理