Tomcat是一款我们平时开发过程中最常用到的Servlet容器。本系列博客会记录Tomcat的整体架构、主要组件、IO线程模型、请求在Tomcat内部的流转过程以及一些Tomcat调优的相关知识。

力求达到以下几个目的：

  • 更加熟悉Tomcat的工作机制，工作中遇到Tomcat相关问题能够快速定位，从源头来解决；
  • 对于一些高并发场景能够对Tomcat进行调优；
  • 通过对Tomcat源码的分析，吸收一些Tomcat的设计的理念，应用到自己的软件开发过程中。

1. Bootstrap启动入口

在前面分析Tomcat启动脚本的过程中，我们最后发现startup.bat最后是通过调用Bootstrap这个类的main方法来启动Tomcat的，所以先去看下Bootstrap这个类。

  1. public static void main(String args[]) {
  3.         synchronized (daemonLock) {
  4.             if (daemon == null) {
  5.                 // Don't set daemon until init() has completed
  6.                 Bootstrap bootstrap = new Bootstrap();
  7.                 try {
  8.                     //创建Bootstrap对象，代用init方法
  9.                     bootstrap.init();
  10.                 } catch (Throwable t) {
  11.                     handleThrowable(t);
  12.                     t.printStackTrace();
  13.                     return;
  14.                 }
  15.                 daemon = bootstrap;
  16.             } else {
  17.                 // When running as a service the call to stop will be on a new
  18.                 // thread so make sure the correct class loader is used to
  19.                 // prevent a range of class not found exceptions.
  20.                 Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
  21.             }
  22.         }
  24.         try {
  25.             String command = "start";
  26.             if (args.length > 0) {
  27.                 command = args[args.length - 1];
  28.             }
  30.             if (command.equals("startd")) {
  31.                 args[args.length - 1] = "start";
  32.                 daemon.load(args);
  33.                 daemon.start();
  34.             } else if (command.equals("stopd")) {
  35.                 args[args.length - 1] = "stop";
  36.                 daemon.stop();
  37.             } else if (command.equals("start")) {
  38.                 //一般情况下会进入这步，调用Bootstrap对象的load和start方法。
  39.                 //将Catalina启动设置成block模式
  40.                 daemon.setAwait(true);
  41.                 daemon.load(args);
  42.                 daemon.start();
  43.                 if (null == daemon.getServer()) {
  44.                     System.exit(1);
  45.                 }
  46.             } else if (command.equals("stop")) {
  47.                 daemon.stopServer(args);
  48.             } else if (command.equals("configtest")) {
  49.                 daemon.load(args);
  50.                 if (null == daemon.getServer()) {
  51.                     System.exit(1);
  52.                 }
  53.                 System.exit(0);
  54.             } else {
  55.                 log.warn("Bootstrap: command \"" + command + "\" does not exist.");
  56.             }
  57.         } catch (Throwable t) {
  58.             // Unwrap the Exception for clearer error reporting
  59.             if (t instanceof InvocationTargetException &&
  60.                     t.getCause() != null) {
  61.                 t = t.getCause();
  62.             }
  63.             handleThrowable(t);
  64.             t.printStackTrace();
  65.             System.exit(1);
  66.         }
  67.     }

上面的代码逻辑比较简单，如果我们正常启动tomcat，会顺序执行Bootstrap对象的init()方法， daemon.setAwait(true)、daemon.load(args)和daemon.start()方法。我们先看下Bootstrap对象的init方法：

  1. public void init() throws Exception {
  3.         initClassLoaders();
  4.         Thread.currentThread().setContextClassLoader(catalinaLoader);
  6.         SecurityClassLoad.securityClassLoad(catalinaLoader);
  8.         // Load our startup class and call its process() method
  9.         if (log.isDebugEnabled())
  10.             log.debug("Loading startup class");
  11.         Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
  12.         Object startupInstance = startupClass.getConstructor().newInstance();
  14.         // Set the shared extensions class loader
  15.         if (log.isDebugEnabled())
  16.             log.debug("Setting startup class properties");
  17.         String methodName = "setParentClassLoader";
  18.         Class<?> paramTypes[] = new Class[1];
  19.         paramTypes[0] = Class.forName("java.lang.ClassLoader");
  20.         Object paramValues[] = new Object[1];
  21.         paramValues[0] = sharedLoader;
  22.         Method method =
  23.             startupInstance.getClass().getMethod(methodName, paramTypes);
  24.         method.invoke(startupInstance, paramValues);
  26.         catalinaDaemon = startupInstance;
  28.     }

这个方法主要做了以下几件事：

  • 创建commonLoader、catalinaLoader、sharedLoader类加载器（默认情况下这三个类加载器指向同一个对象。建议看看createClassLoader方法，里面做的事情还挺多，比如装载catalina.properties里配置的目录下的文件和jar包，后两个加载器的父加载器都是第一个，最后注册了MBean，可以用于JVM监控该对象）；
  • 实例化一个org.apache.catalina.startup.Catalina对象，并赋值给静态成员catalinaDaemon，以sharedLoader作为入参通过反射调用该对象的setParentClassLoader方法。

执行完init()方法，就开始执行bootstrap对象的load和start方法;

  1.  private void load(String[] arguments)
  2.         throws Exception {
  4.         // Call the load() method
  5.         String methodName = "load";
  6.         Object param[];
  7.         Class<?> paramTypes[];
  8.         if (arguments==null || arguments.length==0) {
  9.             paramTypes = null;
  10.             param = null;
  11.         } else {
  12.             paramTypes = new Class[1];
  13.             paramTypes[0] = arguments.getClass();
  14.             param = new Object[1];
  15.             param[0] = arguments;
  16.         }
  17.         Method method =
  18.             catalinaDaemon.getClass().getMethod(methodName, paramTypes);
  19.         if (log.isDebugEnabled())
  20.             log.debug("Calling startup class " + method);
  21.         method.invoke(catalinaDaemon, param);
  23.     }

调用catalinaDaemon对象的load方法，catalinaDaemon这个对象的类型是org.apache.catalina.startup.Catalina。strat方法也是类似的，最后都是调用Catalina的start方法。

总结下Bootstrap的启动方法最主要干的事情就是创建了Catalina对象，并调用它的load和start方法。

2. Catalina的load和start方法

第一节分析到Bootstrap会触发调用Catalina的load和start方法。

  1.      /**
  2.      * 从注释可以看出这个方法的作用是创建一个Server实例
  3.      * Start a new server instance.
  4.      */
  5.     public void load() {
  6.         if (loaded) {
  7.             return;
  8.         }
  9.         loaded = true;
  10.         long t1 = System.nanoTime();
  11.         //检查临时目录
  12.         initDirs();
  13.         // Before digester - it may be needed
  14.         initNaming();
  16.         // Create and execute our Digester
  17.         Digester digester = createStartDigester();
  19.         InputSource inputSource = null;
  20.         InputStream inputStream = null;
  21.         File file = null;
  22.         try {
  23.             try {
  24.                 file = configFile();
  25.                 inputStream = new FileInputStream(file);
  26.                 inputSource = new InputSource(file.toURI().toURL().toString());
  27.             } catch (Exception e) {
  28.                 if (log.isDebugEnabled()) {
  29.                     log.debug(sm.getString("catalina.configFail", file), e);
  30.                 }
  31.             }
  32.             if (inputStream == null) {
  33.                 try {
  34.                     inputStream = getClass().getClassLoader()
  35.                         .getResourceAsStream(getConfigFile());
  36.                     inputSource = new InputSource
  37.                         (getClass().getClassLoader()
  38.                          .getResource(getConfigFile()).toString());
  39.                 } catch (Exception e) {
  40.                     if (log.isDebugEnabled()) {
  41.                         log.debug(sm.getString("catalina.configFail",
  42.                                 getConfigFile()), e);
  43.                     }
  44.                 }
  45.             }
  47.             // This should be included in catalina.jar
  48.             // Alternative: don't bother with xml, just create it manually.
  49.             if (inputStream == null) {
  50.                 try {
  51.                     inputStream = getClass().getClassLoader()
  52.                             .getResourceAsStream("server-embed.xml");
  53.                     inputSource = new InputSource
  54.                     (getClass().getClassLoader()
  55.                             .getResource("server-embed.xml").toString());
  56.                 } catch (Exception e) {
  57.                     if (log.isDebugEnabled()) {
  58.                         log.debug(sm.getString("catalina.configFail",
  59.                                 "server-embed.xml"), e);
  60.                     }
  61.                 }
  62.             }
  64.             if (inputStream == null || inputSource == null) {
  65.                 if  (file == null) {
  66.                     log.warn(sm.getString("catalina.configFail",
  67.                             getConfigFile() + "] or [server-embed.xml]"));
  68.                 } else {
  69.                     log.warn(sm.getString("catalina.configFail",
  70.                             file.getAbsolutePath()));
  71.                     if (file.exists() && !file.canRead()) {
  72.                         log.warn("Permissions incorrect, read permission is not allowed on the file.");
  73.                     }
  74.                 }
  75.                 return;
  76.             }
  78.             try {
  79.                 inputSource.setByteStream(inputStream);
  80.                 digester.push(this);
  81.                 digester.parse(inputSource);
  82.             } catch (SAXParseException spe) {
  83.                 log.warn("Catalina.start using " + getConfigFile() + ": " +
  84.                         spe.getMessage());
  85.                 return;
  86.             } catch (Exception e) {
  87.                 log.warn("Catalina.start using " + getConfigFile() + ": " , e);
  88.                 return;
  89.             }
  90.         } finally {
  91.             if (inputStream != null) {
  92.                 try {
  93.                     inputStream.close();
  94.                 } catch (IOException e) {
  95.                     // Ignore
  96.                 }
  97.             }
  98.         }
  100.         getServer().setCatalina(this);
  101.         getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
  102.         getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
  104.         // Stream redirection
  105.         initStreams();
  107.         // Start the new server
  108.         try {
  109.             getServer().init();
  110.         } catch (LifecycleException e) {
  111.             if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
  112.                 throw new java.lang.Error(e);
  113.             } else {
  114.                 log.error("Catalina.start", e);
  115.             }
  116.         }
  118.         long t2 = System.nanoTime();
  119.         if(log.isInfoEnabled()) {
  120.             log.info("Initialization processed in " + ((t2 - t1) / 1000000) + " ms");
  121.         }
  122.     }

将上面的代码精简下：

  1. Digester digester = createStartDigester();
  2. inputSource.setByteStream(inputStream);
  3. digester.push(this);
  4. digester.parse(inputSource);
  5. getServer().setCatalina(this);
  6. getServer().init();

做的事情就两个：

  • 创建一个Digester对象（Digester对象的作用就是解析server.xml配置文件，这边会先加载conf/server.xml文件，找不到的话会尝试加载server-embed.xml这个配置文件），解析完成后生成org.apache.catalina.core.StandardServer、org.apache.catalina.core.StandardService、org.apache.catalina.connector.Connector、org.apache.catalina.core.StandardEngine、org.apache.catalina.core.StandardHost、org.apache.catalina.core.StandardContext等等一系列对象，这些对象从前到后前一个包含后一个对象的引用（一对一或一对多的关系）。最后将StandardServer赋值给Catalina对象的server属性；如果你配置了连接器组件共享的线程池，还会生成StandardThreadExecutor对象。
  • 第二件事就是调用StandardServer的init方法。

临时总结下：Catalina的load方法的作用主要是解析conf/server.xml，生成StandardServer对象，再触发StandardServer的init方法。

第一节中还分析到Bootstrap会触发调用Catalina的start方法。那么我们看看start方法中干了什么。

  1. /**
  2.      * Start a new server instance.
  3.      */
  4.     public void start() {
  6.         if (getServer() == null) {
  7.             load();
  8.         }
  10.         if (getServer() == null) {
  11.             log.fatal("Cannot start server. Server instance is not configured.");
  12.             return;
  13.         }
  15.         long t1 = System.nanoTime();
  17.         // Start the new server
  18.         try {
  19.             getServer().start();
  20.         } catch (LifecycleException e) {
  21.             log.fatal(sm.getString("catalina.serverStartFail"), e);
  22.             try {
  23.                 getServer().destroy();
  24.             } catch (LifecycleException e1) {
  25.                 log.debug("destroy() failed for failed Server ", e1);
  26.             }
  27.             return;
  28.         }
  30.         long t2 = System.nanoTime();
  31.         if(log.isInfoEnabled()) {
  32.             log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
  33.         }
  35.         // Register shutdown hook
  36.         if (useShutdownHook) {
  37.             if (shutdownHook == null) {
  38.                 shutdownHook = new CatalinaShutdownHook();
  39.             }
  40.             Runtime.getRuntime().addShutdownHook(shutdownHook);
  42.             // If JULI is being used, disable JULI's shutdown hook since
  43.             // shutdown hooks run in parallel and log messages may be lost
  44.             // if JULI's hook completes before the CatalinaShutdownHook()
  45.             LogManager logManager = LogManager.getLogManager();
  46.             if (logManager instanceof ClassLoaderLogManager) {
  47.                 ((ClassLoaderLogManager) logManager).setUseShutdownHook(
  48.                         false);
  49.             }
  50.         }
  52.         if (await) {
  53.             await();
  54.             stop();
  55.         }
  56.     }

这段代码最主要的作用就是调用StandardServer对象的start方法。

总结下：Catalina对象的laod和start方法的作用是解析conf/server.xml，生成StandardServer对象，再触发StandardServer的init方法和start方法。

到这边为止我们可以看到Tomcat的启动流程还是很清晰的，下面继续看StandardServer的init方法和start到底干了些什么。

3.StandardServer的init和start方法

通过寻找StandardServer的init方法，我们发现StandardServer本身没有实现这个方法，这个方法是它从父类LifecycleBase中继承过来的：

  1. @Override
  2.     public final synchronized void init() throws LifecycleException {
  3.         if (!state.equals(LifecycleState.NEW)) {
  4.             invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
  5.         }
  7.         try {
  8.             //发布初始化容器时间，对应的listener做相应处理
  9.             setStateInternal(LifecycleState.INITIALIZING, null, false);
  10.             //调用子类的initInternal（）
  11.             initInternal();
  12.             //发布容器已经初始化事件，对应的listener做相应处理
  13.             setStateInternal(LifecycleState.INITIALIZED, null, false);
  14.         } catch (Throwable t) {
  15.             handleSubClassException(t, "lifecycleBase.initFail", toString());
  16.         }
  17.     }

所以调用StandardServer的init方法，其实是促发了容器初始化事件发布，然后又调到了StandardServer的initInternal方法。那么我们看看StandardServer的start方法的逻辑是什么。

代码点进去，发现StandardServer的start方法也是调的父类LifecycleBase中的方法。

  1. @Override
  2.     public final synchronized void start() throws LifecycleException {
  4.         if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
  5.                 LifecycleState.STARTED.equals(state)) {
  7.             if (log.isDebugEnabled()) {
  8.                 Exception e = new LifecycleException();
  9.                 log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
  10.             } else if (log.isInfoEnabled()) {
  11.                 log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
  12.             }
  14.             return;
  15.         }
  17.         if (state.equals(LifecycleState.NEW)) {
  18.             init();
  19.         } else if (state.equals(LifecycleState.FAILED)) {
  20.             stop();
  21.         } else if (!state.equals(LifecycleState.INITIALIZED) &&
  22.                 !state.equals(LifecycleState.STOPPED)) {
  23.             invalidTransition(Lifecycle.BEFORE_START_EVENT);
  24.         }
  26.         try {
  27.             //发布事件
  28.             setStateInternal(LifecycleState.STARTING_PREP, null, false);
  29.             //调用子类的startInternal
  30.             startInternal();
  31.             if (state.equals(LifecycleState.FAILED)) {
  32.                 // This is a 'controlled' failure. The component put itself into the
  33.                 // FAILED state so call stop() to complete the clean-up.
  34.                 stop();
  35.             } else if (!state.equals(LifecycleState.STARTING)) {
  36.                 // Shouldn't be necessary but acts as a check that sub-classes are
  37.                 // doing what they are supposed to.
  38.                 invalidTransition(Lifecycle.AFTER_START_EVENT);
  39.             } else {
  40.                 //发布容器启动事件
  41.                 setStateInternal(LifecycleState.STARTED, null, false);
  42.             }
  43.         } catch (Throwable t) {
  44.             // This is an 'uncontrolled' failure so put the component into the
  45.             // FAILED state and throw an exception.
  46.             handleSubClassException(t, "lifecycleBase.startFail", toString());
  47.         }
  48.     }

从以上init和start方法的定义可以看到这两个方法最终将会调用StandardServer中定义的initInternal和startInternal。

先来看initInternal方法

  1. protected void initInternal() throws LifecycleException {
  3.         super.initInternal();
  5.         // Register global String cache
  6.         // Note although the cache is global, if there are multiple Servers
  7.         // present in the JVM (may happen when embedding) then the same cache
  8.         // will be registered under multiple names
  9.         onameStringCache = register(new StringCache(), "type=StringCache");
  11.         // Register the MBeanFactory
  12.         MBeanFactory factory = new MBeanFactory();
  13.         factory.setContainer(this);
  14.         onameMBeanFactory = register(factory, "type=MBeanFactory");
  16.         // Register the naming resources
  17.         globalNamingResources.init();
  19.         // Populate the extension validator with JARs from common and shared
  20.         // class loaders
  21.         if (getCatalina() != null) {
  22.             ClassLoader cl = getCatalina().getParentClassLoader();
  23.             // Walk the class loader hierarchy. Stop at the system class loader.
  24.             // This will add the shared (if present) and common class loaders
  25.             while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
  26.                 if (cl instanceof URLClassLoader) {
  27.                     URL[] urls = ((URLClassLoader) cl).getURLs();
  28.                     for (URL url : urls) {
  29.                         if (url.getProtocol().equals("file")) {
  30.                             try {
  31.                                 File f = new File (url.toURI());
  32.                                 if (f.isFile() &&
  33.                                         f.getName().endsWith(".jar")) {
  34.                                     ExtensionValidator.addSystemResource(f);
  35.                                 }
  36.                             } catch (URISyntaxException e) {
  37.                                 // Ignore
  38.                             } catch (IOException e) {
  39.                                 // Ignore
  40.                             }
  41.                         }
  42.                     }
  43.                 }
  44.                 cl = cl.getParent();
  45.             }
  46.         }
  47.         // Initialize our defined Services
  48.         for (int i = 0; i < services.length; i++) {
  49.             services[i].init();
  50.         }
  51.     }

重点代码在最后，循环调用了Service组件的init方法。

再来看StandardServer的startInternal方法

  1. @Override
  2.     protected void startInternal() throws LifecycleException {
  4.         fireLifecycleEvent(CONFIGURE_START_EVENT, null);
  5.         setState(LifecycleState.STARTING);
  7.         globalNamingResources.start();
  9.         // Start our defined Services
  10.         synchronized (servicesLock) {
  11.             for (int i = 0; i < services.length; i++) {
  12.                 services[i].start();
  13.             }
  14.         }
  15.     }

也是循环调用了Service组件的start方法。这边的Service组件就是在从conf/server.xml中解析出来的StandardService对象，查看下这个类的继承体系：

  1. LifecycleBase (org.apache.catalina.util)
  2.     LifecycleMBeanBase (org.apache.catalina.util)
  3.         StandardService (org.apache.catalina.core)

我们发现这个类继承体系和StandardServer是一样的。其实我们再观察的仔细一点会发现从conf/server.xml解析胡来的类的继承体系都是一样的。所以我们调用这些类的init和start方法最后还是会调用到他们的initInternal和startInternal方法。

4. StandardService的initInternal和startInternal方法

先看下StandardService的initInternal方法

  1. @Override
  2.     protected void initInternal() throws LifecycleException {
  4.         super.initInternal();
  5.         //调用engine的initInternal方法，这个方法中也没做特别重要的操作，只是做了一个getReal操作
  6.         if (engine != null) {
  7.             engine.init();
  8.         }
  10.         //StandardThreadExecutor的initInternal方法中没没干什么事情
  11.         // Initialize any Executors
  12.         for (Executor executor : findExecutors()) {
  13.             if (executor instanceof JmxEnabled) {
  14.                 ((JmxEnabled) executor).setDomain(getDomain());
  15.             }
  16.             executor.init();
  17.         }
  19.         // Initialize mapper listener
  20.         //这步也没做什么重要操作
  21.         mapperListener.init();
  23.         // Initialize our defined Connectors
  24.         // 连接器主键的初始化，主要是检查连接器的protocolHandler的主键，并将其初始化.
  25.         synchronized (connectorsLock) {
  26.             for (Connector connector : connectors) {
  27.                 connector.init();
  28.             }
  29.         }
  30.     }

看了上面的代码，觉得Tomcat源码逻辑还是很清晰的。之前在分析Tomcat组件的文章中讲到Service组件是有Connector组件、engine组件和一个可选的线程池组成。上面的代码中正好对应了这三个组件的初始化话。

Connector组件和engine组件的初始化又会触发他们各自子组件的初始化，所以StandardService的initInternal方法会触发Tomcat下各类组件的初始化。这边大致记录下各个组件初始化话的顺序：

  • engine组件初始化：engine组件初始化没做什么特别的操作，也没触发它的子组件（Host、Context和Wrapper组件的初始化），所以这步比较简单;
  • Executor组件的初始化：没有触发其他组件初始化；
  • Mapper组件初始化：mapper组件初始化也没干什么重要的操作，也没触发其他子组件初始化；
  • Connector组件初始化：检查连接器的protocolHandler的子组件，并触发其初始化；
  • ProtocolHandler组件初始化：触发Endpoint组件初始化，Endpoint类才是接收转化请求的真正的类；

然后再看StandardService的startInternal方法

  1. protected void startInternal() throws LifecycleException {
  3.         if(log.isInfoEnabled())
  4.             log.info(sm.getString("standardService.start.name", this.name));
  5.         setState(LifecycleState.STARTING);
  7.         // Start our defined Container first
  8.         if (engine != null) {
  9.             synchronized (engine) {
  10.                 engine.start();
  11.             }
  12.         }
  14.         synchronized (executors) {
  15.             for (Executor executor: executors) {
  16.                 executor.start();
  17.             }
  18.         }
  20.         mapperListener.start();
  22.         // Start our defined Connectors second
  23.         synchronized (connectorsLock) {
  24.             for (Connector connector: connectors) {
  25.                 // If it has already failed, don't try and start it
  26.                 if (connector.getState() != LifecycleState.FAILED) {
  27.                     connector.start();
  28.                 }
  29.             }
  30.         }
  31.     }

逻辑依然很清楚，StandardService会依次触发各个子组件的start方法。

  • Engine组件的start：Engine组件的start方法组要作用还是触发了Host组件的start方法，具体代码见

    1. protected synchronized void startInternal() throws LifecycleException {  
    3.     // Start our subordinate components, if any
    4.     if ((loader != null) && (loader instanceof Lifecycle))
    5.         ((Lifecycle) loader).start();
    6.     logger = null;
    7.     getLogger();
    8.     if ((manager != null) && (manager instanceof Lifecycle))
    9.         ((Lifecycle) manager).start();
    10.     if ((cluster != null) && (cluster instanceof Lifecycle))
    11.         ((Lifecycle) cluster).start();
    12.     Realm realm = getRealmInternal();
    13.     if ((realm != null) && (realm instanceof Lifecycle))
    14.         ((Lifecycle) realm).start();
    15.     if ((resources != null) && (resources instanceof Lifecycle))
    16.         ((Lifecycle) resources).start();  
    18.     // 找出Engine的子容器，也就是Host容器
    19.     Container children[] = findChildren();
    20.     List<Future<Void>> results = new ArrayList<Future<Void>>();
    21.     //利用线程池调用Host的start方法
    22.     for (int i = 0; i < children.length; i++) {
    23.         results.add(startStopExecutor.submit(new StartChild(children[i])));
    24.     }  
    26.     boolean fail = false;
    27.     for (Future<Void> result : results) {
    28.         try {
    29.             result.get();
    30.         } catch (Exception e) {
    31.             log.error(sm.getString("containerBase.threadedStartFailed"), e);
    32.             fail = true;
    33.         }  
    35.     }
    36.     if (fail) {
    37.         throw new LifecycleException(
    38.                 sm.getString("containerBase.threadedStartFailed"));
    39.     }  
    41.     // Start the Valves in our pipeline (including the basic), if any
    42.     if (pipeline instanceof Lifecycle)
    43.         ((Lifecycle) pipeline).start();
    44.     setState(LifecycleState.STARTING);
    45.     // Start our thread
    46.     threadStart();  
    48. }

  • Host组件的start：经过前面介绍，我们知道Host组件的start方法最后还是会调用自己startInternal方法；

  • Context组件的start:触发Wrapper的start，加载filter、Servlet等；

  • Wrapper组件的start:

这边我们重点看下StandardContext的startInternal，这个方法干的事情比较多：

  1.  protected synchronized void startInternal() throws LifecycleException {
  3.         if(log.isDebugEnabled())
  4.             log.debug("Starting " + getBaseName());
  6.         // Send j2ee.state.starting notification
  7.         if (this.getObjectName() != null) {
  8.             Notification notification = new Notification("j2ee.state.starting",
  9.                     this.getObjectName(), sequenceNumber.getAndIncrement());
  10.             broadcaster.sendNotification(notification);
  11.         }
  13.         setConfigured(false);
  14.         boolean ok = true;
  16.         // Currently this is effectively a NO-OP but needs to be called to
  17.         // ensure the NamingResources follows the correct lifecycle
  18.         if (namingResources != null) {
  19.             namingResources.start();
  20.         }
  22.         // Post work directory
  23.         postWorkDirectory();
  25.         // Add missing components as necessary
  26.         if (getResources() == null) {   // (1) Required by Loader
  27.             if (log.isDebugEnabled())
  28.                 log.debug("Configuring default Resources");
  30.             try {
  31.                 setResources(new StandardRoot(this));
  32.             } catch (IllegalArgumentException e) {
  33.                 log.error(sm.getString("standardContext.resourcesInit"), e);
  34.                 ok = false;
  35.             }
  36.         }
  37.         if (ok) {
  38.             resourcesStart();
  39.         }
  41.         if (getLoader() == null) {
  42.             WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
  43.             webappLoader.setDelegate(getDelegate());
  44.             setLoader(webappLoader);
  45.         }
  47.         // An explicit cookie processor hasn't been specified; use the default
  48.         if (cookieProcessor == null) {
  49.             cookieProcessor = new Rfc6265CookieProcessor();
  50.         }
  52.         // Initialize character set mapper
  53.         getCharsetMapper();
  55.         // Validate required extensions
  56.         boolean dependencyCheck = true;
  57.         try {
  58.             dependencyCheck = ExtensionValidator.validateApplication
  59.                 (getResources(), this);
  60.         } catch (IOException ioe) {
  61.             log.error(sm.getString("standardContext.extensionValidationError"), ioe);
  62.             dependencyCheck = false;
  63.         }
  65.         if (!dependencyCheck) {
  66.             // do not make application available if dependency check fails
  67.             ok = false;
  68.         }
  70.         // Reading the "catalina.useNaming" environment variable
  71.         String useNamingProperty = System.getProperty("catalina.useNaming");
  72.         if ((useNamingProperty != null)
  73.             && (useNamingProperty.equals("false"))) {
  74.             useNaming = false;
  75.         }
  77.         if (ok && isUseNaming()) {
  78.             if (getNamingContextListener() == null) {
  79.                 NamingContextListener ncl = new NamingContextListener();
  80.                 ncl.setName(getNamingContextName());
  81.                 ncl.setExceptionOnFailedWrite(getJndiExceptionOnFailedWrite());
  82.                 addLifecycleListener(ncl);
  83.                 setNamingContextListener(ncl);
  84.             }
  85.         }
  87.         // Standard container startup
  88.         if (log.isDebugEnabled())
  89.             log.debug("Processing standard container startup");
  91.         // Binding thread
  92.         ClassLoader oldCCL = bindThread();
  94.         try {
  95.             if (ok) {
  96.                 // Start our subordinate components, if any
  97.                 Loader loader = getLoader();
  98.                 if (loader instanceof Lifecycle) {
  99.                     ((Lifecycle) loader).start();
  100.                 }
  102.                 // since the loader just started, the webapp classloader is now
  103.                 // created.
  104.                 setClassLoaderProperty("clearReferencesRmiTargets",
  105.                         getClearReferencesRmiTargets());
  106.                 setClassLoaderProperty("clearReferencesStopThreads",
  107.                         getClearReferencesStopThreads());
  108.                 setClassLoaderProperty("clearReferencesStopTimerThreads",
  109.                         getClearReferencesStopTimerThreads());
  110.                 setClassLoaderProperty("clearReferencesHttpClientKeepAliveThread",
  111.                         getClearReferencesHttpClientKeepAliveThread());
  112.                 setClassLoaderProperty("clearReferencesObjectStreamClassCaches",
  113.                         getClearReferencesObjectStreamClassCaches());
  114.                 setClassLoaderProperty("skipMemoryLeakChecksOnJvmShutdown",
  115.                         getSkipMemoryLeakChecksOnJvmShutdown());
  117.                 // By calling unbindThread and bindThread in a row, we setup the
  118.                 // current Thread CCL to be the webapp classloader
  119.                 unbindThread(oldCCL);
  120.                 oldCCL = bindThread();
  122.                 // Initialize logger again. Other components might have used it
  123.                 // too early, so it should be reset.
  124.                 logger = null;
  125.                 getLogger();
  127.                 Realm realm = getRealmInternal();
  128.                 if(null != realm) {
  129.                     if (realm instanceof Lifecycle) {
  130.                         ((Lifecycle) realm).start();
  131.                     }
  133.                     // Place the CredentialHandler into the ServletContext so
  134.                     // applications can have access to it. Wrap it in a "safe"
  135.                     // handler so application's can't modify it.
  136.                     CredentialHandler safeHandler = new CredentialHandler() {
  137.                         @Override
  138.                         public boolean matches(String inputCredentials, String storedCredentials) {
  139.                             return getRealmInternal().getCredentialHandler().matches(inputCredentials, storedCredentials);
  140.                         }
  142.                         @Override
  143.                         public String mutate(String inputCredentials) {
  144.                             return getRealmInternal().getCredentialHandler().mutate(inputCredentials);
  145.                         }
  146.                     };
  147.                     context.setAttribute(Globals.CREDENTIAL_HANDLER, safeHandler);
  148.                 }
  150.                 // Notify our interested LifecycleListeners
  151.                 fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);
  153.                 // Start our child containers, if not already started
  154.                 for (Container child : findChildren()) {
  155.                     if (!child.getState().isAvailable()) {
  156.                         child.start();
  157.                     }
  158.                 }
  160.                 // Start the Valves in our pipeline (including the basic),
  161.                 // if any
  162.                 if (pipeline instanceof Lifecycle) {
  163.                     ((Lifecycle) pipeline).start();
  164.                 }
  166.                 // Acquire clustered manager
  167.                 Manager contextManager = null;
  168.                 Manager manager = getManager();
  169.                 if (manager == null) {
  170.                     if (log.isDebugEnabled()) {
  171.                         log.debug(sm.getString("standardContext.cluster.noManager",
  172.                                 Boolean.valueOf((getCluster() != null)),
  173.                                 Boolean.valueOf(distributable)));
  174.                     }
  175.                     if ( (getCluster() != null) && distributable) {
  176.                         try {
  177.                             contextManager = getCluster().createManager(getName());
  178.                         } catch (Exception ex) {
  179.                             log.error("standardContext.clusterFail", ex);
  180.                             ok = false;
  181.                         }
  182.                     } else {
  183.                         contextManager = new StandardManager();
  184.                     }
  185.                 }
  187.                 // Configure default manager if none was specified
  188.                 if (contextManager != null) {
  189.                     if (log.isDebugEnabled()) {
  190.                         log.debug(sm.getString("standardContext.manager",
  191.                                 contextManager.getClass().getName()));
  192.                     }
  193.                     setManager(contextManager);
  194.                 }
  196.                 if (manager!=null && (getCluster() != null) && distributable) {
  197.                     //let the cluster know that there is a context that is distributable
  198.                     //and that it has its own manager
  199.                     getCluster().registerManager(manager);
  200.                 }
  201.             }
  203.             if (!getConfigured()) {
  204.                 log.error(sm.getString("standardContext.configurationFail"));
  205.                 ok = false;
  206.             }
  208.             // We put the resources into the servlet context
  209.             if (ok)
  210.                 getServletContext().setAttribute
  211.                     (Globals.RESOURCES_ATTR, getResources());
  213.             if (ok ) {
  214.                 if (getInstanceManager() == null) {
  215.                     javax.naming.Context context = null;
  216.                     if (isUseNaming() && getNamingContextListener() != null) {
  217.                         context = getNamingContextListener().getEnvContext();
  218.                     }
  219.                     Map<String, Map<String, String>> injectionMap = buildInjectionMap(
  220.                             getIgnoreAnnotations() ? new NamingResourcesImpl(): getNamingResources());
  221.                     setInstanceManager(new DefaultInstanceManager(context,
  222.                             injectionMap, this, this.getClass().getClassLoader()));
  223.                 }
  224.                 getServletContext().setAttribute(
  225.                         InstanceManager.class.getName(), getInstanceManager());
  226.                 InstanceManagerBindings.bind(getLoader().getClassLoader(), getInstanceManager());
  227.             }
  229.             // Create context attributes that will be required
  230.             if (ok) {
  231.                 getServletContext().setAttribute(
  232.                         JarScanner.class.getName(), getJarScanner());
  233.             }
  235.             // Set up the context init params
  236.             mergeParameters();
  238.             // Call ServletContainerInitializers
  239.             for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry :
  240.                 initializers.entrySet()) {
  241.                 try {
  242.                     entry.getKey().onStartup(entry.getValue(),
  243.                             getServletContext());
  244.                 } catch (ServletException e) {
  245.                     log.error(sm.getString("standardContext.sciFail"), e);
  246.                     ok = false;
  247.                     break;
  248.                 }
  249.             }
  251.             // Configure and call application event listeners
  252.             if (ok) {
  253.                 if (!listenerStart()) {
  254.                     log.error(sm.getString("standardContext.listenerFail"));
  255.                     ok = false;
  256.                 }
  257.             }
  259.             // Check constraints for uncovered HTTP methods
  260.             // Needs to be after SCIs and listeners as they may programmatically
  261.             // change constraints
  262.             if (ok) {
  263.                 checkConstraintsForUncoveredMethods(findConstraints());
  264.             }
  266.             try {
  267.                 // Start manager
  268.                 Manager manager = getManager();
  269.                 if (manager instanceof Lifecycle) {
  270.                     ((Lifecycle) manager).start();
  271.                 }
  272.             } catch(Exception e) {
  273.                 log.error(sm.getString("standardContext.managerFail"), e);
  274.                 ok = false;
  275.             }
  277.             // Configure and call application filters
  278.             if (ok) {
  279.                 if (!filterStart()) {
  280.                     log.error(sm.getString("standardContext.filterFail"));
  281.                     ok = false;
  282.                 }
  283.             }
  285.             // Load and initialize all "load on startup" servlets
  286.             if (ok) {
  287.                 if (!loadOnStartup(findChildren())){
  288.                     log.error(sm.getString("standardContext.servletFail"));
  289.                     ok = false;
  290.                 }
  291.             }
  293.             // Start ContainerBackgroundProcessor thread
  294.             super.threadStart();
  295.         } finally {
  296.             // Unbinding thread
  297.             unbindThread(oldCCL);
  298.         }
  300.         // Set available status depending upon startup success
  301.         if (ok) {
  302.             if (log.isDebugEnabled())
  303.                 log.debug("Starting completed");
  304.         } else {
  305.             log.error(sm.getString("standardContext.startFailed", getName()));
  306.         }
  308.         startTime=System.currentTimeMillis();
  310.         // Send j2ee.state.running notification
  311.         if (ok && (this.getObjectName() != null)) {
  312.             Notification notification =
  313.                 new Notification("j2ee.state.running", this.getObjectName(),
  314.                                  sequenceNumber.getAndIncrement());
  315.             broadcaster.sendNotification(notification);
  316.         }
  318.         // The WebResources implementation caches references to JAR files. On
  319.         // some platforms these references may lock the JAR files. Since web
  320.         // application start is likely to have read from lots of JARs, trigger
  321.         // a clean-up now.
  322.         getResources().gc();
  324.         // Reinitializing if something went wrong
  325.         if (!ok) {
  326.             setState(LifecycleState.FAILED);
  327.         } else {
  328.             setState(LifecycleState.STARTING);
  329.         }
  330.     }

上面的代码有4处重点：调用ServletContainerInitializers、启用Listener、启用Filter和启用startup的Servlet。这个和我们平时对Tomcat启动流程的认知是一致的。

到这里整个Container组件（包括Engine、Host、Context和Wrapper组件）的start方法调用就结束了。接下来是Connector和Mapper组件的start。

  1. //MapperListenner的startInternal
  2. public void startInternal() throws LifecycleException {
  4.         setState(LifecycleState.STARTING);
  6.         Engine engine = service.getContainer();
  7.         if (engine == null) {
  8.             return;
  9.         }
  11.         findDefaultHost();
  13.         addListeners(engine);
  15.         Container[] conHosts = engine.findChildren();
  16.         for (Container conHost : conHosts) {
  17.             Host host = (Host) conHost;
  18.             if (!LifecycleState.NEW.equals(host.getState())) {
  19.                 // Registering the host will register the context and wrappers
  20.                 registerHost(host);
  21.             }
  22.         }
  23.     }

以上方法的主要作用是将Host组件和域名映射起来。

最后看下Connector组件的start：

  1. protected void startInternal() throws LifecycleException {
  3.         // Validate settings before starting
  4.         if (getPortWithOffset() < 0) {
  5.             throw new LifecycleException(sm.getString(
  6.                     "coyoteConnector.invalidPort", Integer.valueOf(getPortWithOffset())));
  7.         }
  9.         setState(LifecycleState.STARTING);
  11.         try {
  12.             //促发protocolHandler组件的start，最后促发endpoint组件的start
  13.             //触发endpoint时会建立exceutor线程池，默认的话核心线程数10，最大线程数200
  14.             //建立poller线程，最大是2个线程，如果你机器cpu的核数小于2的话就建立1个
  15.             //建立accetpor线程，默认是1个（可以看看Acceptor这个类的源代码，了解下怎么接收请求的）
  16.             protocolHandler.start();
  17.         } catch (Exception e) {
  18.             throw new LifecycleException(
  19.                     sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
  20.         }
  21.     }

通过以上一些列复杂的调用过程，最终执行完所有在server.xml里配置的节点的实现类中initInternal和startInternal方法。上面提到的org.apache.catalina.core.StandardServer、org.apache.catalina.core.StandardService、org.apache.catalina.connector.Connector、org.apache.catalina.core.StandardEngine、org.apache.catalina.core.StandardHost、org.apache.catalina.core.StandardContext等等组件的这两个方法都会调用到。

至此，Tomcat已经能开始响应浏览器发过来的请求了。至于具体的Tomcat响应请求流程会在后续博客中介绍。

5. 总结

看了整个启动流程，虽然逻辑是比较清楚的，但是流程比较上，所以有必要做下总结：

  • step1：Bootstrap作为整个Tomcat主启动类，最主要的功能是创建Catalina对象，并调用它的load和start方法；

  • step2：Catalina的load方法的作用主要是解析conf/server.xml，生成StandardServer对象（此时生成StandardServer对象中已经包含了各种子组件，比如StandardService、StandardEngine等），再触发StandardServer的init方法；Catalina的start方法又触发了StandardServer的start方法；

  • step3：StandardServer的init方法和start方法会依次触发各个子组件的initInternal和startInternal方法。大致的触发顺序是：

    Engine组件的initInternal（这边要注意的是Engine组件并没有触发它的子组件Host、Context和Wrapper的initInternal）-->Executor组件initInternal（处理请求的工作线程池）-->Mapper组件初始化（mapper组件初始化也没干什么重要的操作，也没触发其他子组件初始化）-->Connector组件初始化（检查连接器的protocolHandler的子组件，并触发其初始化）-->ProtocolHandler组件初始化(触发Endpoint组件初始化)​

​ Engine组件的startInternal（主要作用是触发Host组件的start）-->Host组件的startInternal（主要作用是触发Context组件的startInternal）-->Contextz组件的startInternal（加载调用ServletContainerInitializers、加载Listener、加载filtr和startup的Servlet，并且触发Wrapper组件的startInternal）-->Wrapper组件的startInternal（加载映射Servlet）-->Mapper组件的startInternal（将域名和Host组件映射起来）-->Connector组件的startInternal（protocolHandler组件的start，最后促发endpoint组件的start）

Tomcat启动流程简析的更多相关文章

  1. React Native 启动流程简析

    导读:本文以 react-native-cli 创建的示例工程(安卓部分)为例,分析 React Native 的启动流程. 工程创建步骤可以参考官网.本文所分析 React Native 版本为 v ...

  2. Android 启动过程简析

    首先我们先来看android构架图: android系统是构建在linux系统上面的. 所以android设备启动经历3个过程. Boot Loader,Linux Kernel & Andr ...

  3. zxing二维码扫描的流程简析（Android版）

    目前市面上二维码的扫描似乎用开源google的zxing比较多,接下去以2.2版本做一个简析吧,勿喷... 下载下来后定位两个文件夹,core和android,core是一些核心的库,android是 ...

  4. OpenStack Cinder源代码流程简析

    版权声明:本博客欢迎转载,转载时请以超链接形式标明文章原始出处!谢谢! 博客地址:http://blog.csdn.net/i_chips 一.概况 OpenStack的各个模块都有对应的client ...

  5. TOMCAT启动流程分析

    ------------------tomcat服务开启----------2014-9-26 9:17:07 org.apache.catalina.core.AprLifecycleListene ...

  6. tomcat 工作原理简析

    https://github.com/HappyTomas/another-tutorial-about-java-web/blob/master/00-08.md 在00-02.理解HTTP中给出了 ...

  7. Tomcat和Servlet简析

    目录 Servlet Tomcat 参考 Servlet Servlet通常指我们继承了Servlet接口的类,我们开发Servlet时一般就是继承HttpServlet重写它的doGet.doPos ...

  8. LinkedHashMap结构get和put源码流程简析及LRU应用

    原理这篇讲得比较透彻Java集合之LinkedHashMap. 本文属于源码阅读笔记,因put,get调用逻辑及链表维护逻辑复杂(至少网上其它文章的逻辑描述及配图,我都没看明白LinkedHashMa ...

  9. jquery选择器的实现流程简析及提高性能建议！

    当我们洋洋得意的使用jquery强大的选择器功能时有没有在意过jquery的选择性能问题呢,其实要想高效的使用jquery选择器,了解其实现流程是很有必要的,那么这篇文章我就简单的讲讲其实现流程,相信 ...

随机推荐

  1. Java实现 LeetCode 71 简化路径

    71. 简化路径 以 Unix 风格给出一个文件的绝对路径,你需要简化它.或者换句话说,将其转换为规范路径. 在 Unix 风格的文件系统中,一个点(.)表示当前目录本身:此外,两个点 (-) 表示将 ...

  2. Java实现 LeetCode 12 整数转罗马数字

    12. 整数转罗马数字 罗马数字包含以下七种字符: I, V, X, L,C,D 和 M. 字符 数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如, 罗马数字 2 ...

  3. Java实现第八届蓝桥杯迷宫

    迷宫 题目描述 X星球的一处迷宫游乐场建在某个小山坡上. 它是由10x10相互连通的小房间组成的. 房间的地板上写着一个很大的字母. 我们假设玩家是面朝上坡的方向站立,则: L表示走到左边的房间, R ...

  4. XStrea学习手册

    ​​ 一.前言 1.XStream官网 http://x-stream.github.io 2.XStream是什么 XStream是一个简单的基于Java的类库,用来将Java对象序列化成XML(J ...

  5. 2018年全国多校算法寒假训练营练习比赛（第二场）H-了断局

    题目描述 既然是了断局了,大家就随便玩玩数字呗.已知一个数列前十项分别是{0, 1, 1, 2, 4, 7, 13, 24, 44, 81},小G不满足呀:我要更多的数!!!不给就不让你们玩了.小G会 ...

  6. 温故知新-Mysql锁&事务&MVCC

    文章目录 锁概述 锁分类 MyISAM 表锁 InnoDB 行锁 事务及其ACID属性 InnoDB 的行锁模式 注意 MVCC InnoDB 中的 MVCC 参考 你的鼓励也是我创作的动力 Post ...

  7. css3图片防止变形

    1.object-fit 由于图片原始大小都不一样,强行设定大小值会导致拉伸,如果不设定大小则参差不齐. 之前我们大多数用的 大多数都是利用background-size: cover 来避免对图片造 ...

  8. XAI/MLI 可解释机器学习系列1- 开源&paper汇总

    一直在关注可解释机器学习领域,因为确实在工作中有许多应用 模型检查,特征重要性是否符合预期和AUC一样重要 模型解释,比起虚无缥缈的模型指标,解释模型学到的规律更能说服业务方 样本解释,为什么这些用户 ...

  9. http的几种请求方法

    1.HTTP请求方法有以下8种方法:OPTIONS.GET.HEAD.POST.PUT.DELETE.TRACE和CONNECT. GET GET请求会显示请求指定的资源.一般来说GET方法应该只用于 ...

  10. 淘宝官网css初始化

    body, h1, h2, h3, h4, h5, h6, hr, p, blockquote, dl, dt, dd, ul, ol, li, pre, form, fieldset, legend ...