Tomcat源码剖析（五）Tomcat如何管理Servlet生命周期

【问题】

Servlet规范中规定Servlet生命周期只调用一次init()和distory()方法，每次请求来只调用service()方法，那么Tomcat是如何管理Servlet生命周期的？

高并发请求中，如果保证只初始化一个Servlet？
如和实现loadOnStartup参数的功能？

【猜想】

按照Servlet的规范，一定需要缓存Servlet对象，如果是我来做的话，应该会使用Map缓存，每次请求判断一下Servlet是否在Map中，若不存在，就load() servlet然后存进Map。

在高并发的情况下，肯定得用线程安全的ConcurrentHashMap,

对于loadOnStartup参数，可以使用TreeSet排序初始化

【Tomcat】

Tomcat的实现并不是如此，在Tomcat中，每个Servlet都有一个对应的StandardWrapper，而在前面我们分析过在Tomcat启动的时候，会调用Server,Connector,以及各个容器的strat()方法，其中在Context的start()方法中，就会首先加载所有的StandardWrapper，这个StandardWrapper中包含了Servlet对象，只是当在调用对应的Servlet方法后，StandardWrapper会检查Servlet是否被加载过，如果没有加载，则加载，如果加载过了，则直接使用。

前一篇关于分析[Tomcat如何解析Url找到对应的Servlet](<https://service-h580ssv7-1257812551.bj.apigw.tencentcs.com/?p=1065>)的文章中说过，Serlvet的匹配其实算是一个树形结构，每个Host会缓存多个Context，每个Context会缓存多个StandardWrapper，因此，StandardWrapper在系统启动的时候就已经被加载了，只是Servlet是通过LoadOnStartup`参数配置的。

对于Servlet只初始化一个的问题，Tomcat使用的是典型的单例类中的双重检验完成的。

对于loadOnStartup，Tomcat则使用的是TreeMap实现，这一点我确实没相当，刚开始我说TreeSet，是因为我直接将Servelt重写Comparable接口，使用loadOnStartup属性作为对比的对象，但是这样实现远没有TreeMap中将loadOnStartup作为key简洁。

整体说下流程：

加载

Context在启动的时候，并不会自己去寻找Child,也就是StandardWrapper,而是在初始化之前，有一个ContextConfig会监听StandardContext的所有时间，当Context触发了Start事件的时候，ContextConfig便会遍历CATLINA_HOME下的所有目录，去读取所有的war以及各个文件夹，对于war包，会先解压War包，然后将信息生成StandardWrapper加入到StandardContext中。

那么loadOnStartup这个参数是怎么实现的呢？

当加入到Child之后，StardandContext的start()方法会遍历所有的Child，当发现loadOnStartup大于0之后，会获取loadOnStartUp配置文件的值，然后将它的值作为key加入到TreeMap中，后续再遍历这个map依次loadServlet即可.

使用

Servlet使用就非常简单了，当一个请求到来了，Servlet的Mapper会通过规则查找到对应的SerlvetWarpper,而StandardWrapper便会在真正调用Servlet的时候判断Serlvet是否已经加载过，如果没有，则先加载。

卸载

Serlvet卸载就比较简单了，在系统关闭的时候，会触发StandardWrapper,StandardWrapper会调用Stop()方法，从而调用SerlvetWarpper的unload()方法，而unload()方法中就会调用Servlet的destory()方法

【代码】

这里代码比较散，而且还包含其他业务，因此便不全部贴出来.

加载1

ContextConfig##configureContext()

//读取webxml中servlet节点配置 
for (ServletDef servlet : webxml.getServlets().values()) {
            Wrapper wrapper = context.createWrapper();
            //设置LoadOnStartup 属性
            if (servlet.getLoadOnStartup() != null) {
                wrapper.setLoadOnStartup(servlet.getLoadOnStartup().intValue());
            }
            //设置Servlet是否有效
            if (servlet.getEnabled() != null) {
                wrapper.setEnabled(servlet.getEnabled().booleanValue());
            }
            // 设置name
            wrapper.setName(servlet.getServletName());
            // 设置初始化参数
            Map<String,String> params = servlet.getParameterMap();
            for (Entry<String, String> entry : params.entrySet()) {
                wrapper.addInitParameter(entry.getKey(), entry.getValue());
            }
            wrapper.setRunAs(servlet.getRunAs());
            Set<SecurityRoleRef> roleRefs = servlet.getSecurityRoleRefs();
            for (SecurityRoleRef roleRef : roleRefs) {
                wrapper.addSecurityReference(
                        roleRef.getName(), roleRef.getLink());
            }
            //设置servlet映射的类
            wrapper.setServletClass(servlet.getServletClass());
            MultipartDef multipartdef = servlet.getMultipartDef();
            if (multipartdef != null) {
                if (multipartdef.getMaxFileSize() != null &&
                        multipartdef.getMaxRequestSize()!= null &&
                        multipartdef.getFileSizeThreshold() != null) {
                    wrapper.setMultipartConfigElement(new MultipartConfigElement(
                            multipartdef.getLocation(),
                            Long.parseLong(multipartdef.getMaxFileSize()),
                            Long.parseLong(multipartdef.getMaxRequestSize()),
                            Integer.parseInt(
                                    multipartdef.getFileSizeThreshold())));
                } else {
                    wrapper.setMultipartConfigElement(new MultipartConfigElement(
                            multipartdef.getLocation()));
                }
            }
            if (servlet.getAsyncSupported() != null) {
                wrapper.setAsyncSupported(
                        servlet.getAsyncSupported().booleanValue());
            }
            wrapper.setOverridable(servlet.isOverridable());
            //将配置好的servlet对象作为Child加入到context中
            context.addChild(wrapper);
        }

加载2

StandardContext##startInternal()

// Load and initialize all "load on startup" servlets
if (ok) {
    if (!loadOnStartup(findChildren())){
        log.error(sm.getString("standardContext.servletFail"));
        ok = false;
    }
}

 */
public boolean loadOnStartup(Container children[]) {

    // Collect "load on startup" servlets that need to be initialized
    TreeMap<Integer, ArrayList<Wrapper>> map = new TreeMap<>();
     //遍历所有子对象
    for (int i = 0; i < children.length; i++) {
        Wrapper wrapper = (Wrapper) children[i];
        int loadOnStartup = wrapper.getLoadOnStartup();
        //如果loadOnStartup值小于0,则跳过
        if (loadOnStartup < 0)
            continue;
        //否则将它对应的值作为key加入到TreeMap中，这样值越小，就越会先遍历到
        //也就是loadOnStartup值越小，就越先加载
        Integer key = Integer.valueOf(loadOnStartup);
        ArrayList<Wrapper> list = map.get(key);
        if (list == null) {
            list = new ArrayList<>();
            map.put(key, list);
        }

        list.add(wrapper);
    }

    //加载servlet
    for (ArrayList<Wrapper> list : map.values()) {
        for (Wrapper wrapper : list) {
            try {
                wrapper.load();
            } catch (ServletException e) {
                getLogger().error(sm.getString("standardContext.loadOnStartup.loadException",
                      getName(), wrapper.getName()), StandardWrapper.getRootCause(e));
                // NOTE: load errors (including a servlet that throws
                // UnavailableException from the init() method) are NOT
                // fatal to application startup
                // unless failCtxIfServletStartFails="true" is specified
                if(getComputedFailCtxIfServletStartFails()) {
                    return false;
                }
            }
        }
    }
    return true;

}

使用

这里使用就是典型的双重检验实现单例了

 if (instance == null || !instanceInitialized) {
                synchronized (this) {
                    if (instance == null) {
                        try {
                            instance = loadServlet();
                            newInstance = true;
                    }
                    if (!instanceInitialized) {
                        initServlet(instance);
                    }
                }
            }

这里再复习一下双重校验单例：

instance必须为volatile,为了防止JVM优化而改变代码顺序
因为new不是一个原子操作，new一个对象分为以下三步：

创建对象，分配内存

执行构造方法初始化内存

将instance指向分配的内存地址,（此时Instance变不为空了）

而上面的执行顺序由于JVM的指令重排的优化，可能改为了1->3->2，在单线程看来是没有毛病的，但是多线程中很可能第二个线程在判断是否为null的时候，instance仅仅被分配了内存，却没有执行构造方法，这个时候第二个线程拿到的可能就是一个不完整的instance

销毁

销毁就没什么好说了了

StandardWrapper##stop()

@Override
protected synchronized void stopInternal() throws LifecycleException {
      unload();
}

@Override
public synchronized void unload() throws ServletException {
      if (instanceInitialized) {
        instance.destroy();
      }
}

Tomcat源码剖析（五）Tomcat如何管理Servlet生命周期

ContextConfig##configureContext()

StandardContext##startInternal()

StandardWrapper##stop()

发布者

dengchengchao