记一次高并发服务的FULL GC问题排查与修复（2/2）

// 最新版为AtomicReference，而服务中版本还是真数组
private volatile Handler[] _handlers;
protected final AtomicReference<Handlers> _handlers = new AtomicReference<>();

/******** WebAppContext ********/
@Override
protected void doStart() throws Exception {
  try
        {
            // 省略前
            preConfigure();
            // 这里一路向上，可以看到在ContextHandler中处理了一系列类加载器
            // 最终还是调用了this.startContext();而WebAppContext中有所重载
            super.doStart();
            postConfigure();
            // 省略后
        }
        catch (Throwable t) {
            // 省略
      }        
}
@Override
protected void startContext()
    throws Exception {
   // 新版有所优化，先确保了 configure()成功才会接着执行。。。（其实就是加了个if）
    configure();
    // xml解析
    _metadata.resolve(this);
    // 继续start，最终启动app
    super.startContext();
}

// 新版多封装了一层_configurations，先sort了一下;老版（此文服务）直接for循环调用
// preConfigure 以及 postConfigure类似
public boolean configure() throws Exception {
      // return _configurations.configure(this);
      for(int i = 0; i < this._configurations.length; ++i) {
          this._configurations[i].preConfigure(this);
      }
}

/******** Configuration interface ********/
void preConfigure(WebAppContext context) throws Exception;
void configure(WebAppContext context) throws Exception;
void postConfigure(WebAppContext context) throws Exception;
// 其他方法，例如clone省略

/******** AnnotationConfiguration ********/
 @Override
public void configure(WebAppContext context) throws Exception
    {
        // 省略
        // 顾名思义，此处为扫所有的注解
        if (!_discoverableAnnotationHandlers.isEmpty() || _classInheritanceHandler != null || !_containerInitializerAnnotationHandlers.isEmpty())
            scanForAnnotations(context);
        // 省略
    }
/**
  * Perform scanning of classes for discoverable
  * annotations such as WebServlet/WebFilter/WebListener
  *
  * @param context the context for the scan
  * @throws Exception if unable to scan
*/
    protected void scanForAnnotations(WebAppContext context)
        throws Exception
    {
        // JAVA版本相关，省略
        // 日志打印，省略
        //scan selected jars on the container classpath first
        parseContainerPath(context, parser);
        //email from Rajiv Mordani jsrs 315 7 April 2010
        //    If there is a <others/> then the ordering should be
        //          WEB-INF/classes the order of the declared elements + others.
        //    In case there is no others then it is
        //          WEB-INF/classes + order of the elements.
        parseWebInfClasses(context, parser);
        //scan non-excluded, non medatadata-complete jars in web-inf lib
        parseWebInfLib(context, parser);
        //execute scan, either effectively synchronously (1 thread only), or asynchronously (limited by number of processors available) 
        final Semaphore task_limit = (isUseMultiThreading(context) ? new Semaphore(ProcessorUtils.availableProcessors()) : new Semaphore(1));
        final CountDownLatch latch = new CountDownLatch(_parserTasks.size());
        final MultiException me = new MultiException();
        for (final ParserTask p : _parserTasks)
        {
            task_limit.acquire();
            context.getServer().getThreadPool().execute(new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        p.call();
                    }
                    catch (Exception e)
                    {
                        me.add(e);
                    }
                    finally
                    {
                        task_limit.release();
                        latch.countDown();
                    }
                }
            });
        }
        // ...
    }

 /**
  * Scan jars in WEB-INF/lib. Only jars selected by MetaInfConfiguration,  and that are not excluded by an ordering will be considered.
  */
public void parseWebInfLib(final WebAppContext context, final AnnotationParser parser) throws Exception
    {
        List<Resource> jars = context.getMetaData().getWebInfResources(context.getMetaData().isOrdered());
        for (Resource r : jars)
        {
            //for each jar, we decide which set of annotations we need to parse for
            final Set<Handler> handlers = new HashSet<Handler>();
            FragmentDescriptor f = context.getMetaData().getFragmentDescriptorForJar(r);
            //if its from a fragment jar that is metadata complete, we should skip scanning for @webservlet etc
            // but yet we still need to do the scanning for the classes on behalf of  the servletcontainerinitializers
            //if a jar has no web-fragment.xml we scan it (because it is not excluded by the ordering)
            //or if it has a fragment we scan it if it is not metadata complete
            if (f == null || !WebDescriptor.isMetaDataComplete(f) || _classInheritanceHandler != null || !_containerInitializerAnnotationHandlers.isEmpty())
            {
                //register the classinheritance handler if there is one
                if (_classInheritanceHandler != null)
                    handlers.add(_classInheritanceHandler);
                //register the handlers for the @HandlesTypes values that are themselves annotations if there are any
                handlers.addAll(_containerInitializerAnnotationHandlers);
                //only register the discoverable annotation handlers if this fragment is not metadata complete, or has no fragment descriptor
                if (f == null || !WebDescriptor.isMetaDataComplete(f))
                    handlers.addAll(_discoverableAnnotationHandlers);
                if (_parserTasks != null)
                {
                    // 注：都是这个task，说明内部parse逻辑还有区别
                    ParserTask task = new ParserTask(parser, handlers, r);
                    _parserTasks.add(task);
                }
            }
        }
    }

/******** AnnotationParser ********/
    /**
     * Parse a resource
     * @param handlers the handlers to look for classes in
     * @param r the resource to parse
     * @throws Exception if unable to parse
     */
    public void parse(final Set<? extends Handler> handlers, Resource r) throws Exception
    {
        if (r == null)
            return;
        if (r.exists() && r.isDirectory())
        {
            parseDir(handlers, r);
            return;
        }
        String fullname = r.toString();
        if (fullname.endsWith(".jar"))
        {
          // 主要看这个，对应着jar包
            parseJar(handlers, r);
            return;
        }
        if (fullname.endsWith(".class"))
        {
            try (InputStream is = r.getInputStream())
            {
                scanClass(handlers, null, is);
                return;
            }
        }
        // ...
    }
    /**
     * Parse a resource that is a jar file.
     *
     * @param handlers the handlers to look for classes in
     * @param jarResource the jar resource to parse
     * @throws Exception if unable to parse
     */
    protected void parseJar(Set<? extends Handler> handlers, Resource jarResource) throws Exception
    {
        if (jarResource == null)
            return;
        if (jarResource.toString().endsWith(".jar"))
        {
            MultiException me = new MultiException();
            try (MultiReleaseJarFile jarFile = new MultiReleaseJarFile(jarResource.getFile(), _javaPlatform, false))
            {
                // 封装成JarInputStream以便解压
                jarFile.stream().forEach(e ->
                {
                    try
                    {
                        // 具体处理逻辑
                        parseJarEntry(handlers, jarResource, e);
                    }
                    catch (Exception ex)
                    {
                        me.add(new RuntimeException("Error scanning entry " + e.getName() + " from jar " + jarResource, ex));
                    }
                });
            }
            me.ifExceptionThrow();
        }
    }

/******** AnnotationParser ********/
    /**
     * Parse a single entry in a jar file
     * @param handlers the handlers to look for classes in
     * @param entry the entry in the potentially MultiRelease jar resource to parse
     * @param jar the jar file
     * @throws Exception if unable to parse
     */
    protected void parseJarEntry(Set<? extends Handler> handlers, Resource jar, MultiReleaseJarFile.VersionedJarEntry entry)
        throws Exception
    {
        if (jar == null || entry == null)
            return;
        //skip directories
        if (entry.isDirectory())
            return;

        String name = entry.getName();
        //check file is a valid class file name
        if (isValidClassFileName(name) && isValidClassFilePath(name))
        {
            String shortName = StringUtil.replace(name, '/', '.').substring(0, name.length() - 6);
            // 资源组装
            addParsedClass(shortName, Resource.newResource("jar:" + jar.getURI() + "!/" + entry.getNameInJar()));
            if (LOG.isDebugEnabled())
                LOG.debug("Scanning class from jar {}!/{}", jar, entry);
            try (InputStream is = entry.getInputStream())
            {
                // 前面有出现过。asm解析类文件
                scanClass(handlers, jar, is);
            }
        }
    }
/******** Resource ********/
    public static Resource newResource(URL url)
    {
        return newResource(url, __defaultUseCaches);
    }
   /**
     * Construct a resource from a url.
     * @param url the url for which to make the resource
     * @param useCaches true enables URLConnection caching if applicable to the type of resource
     * @return a new resource from the given URL
     */
    static Resource newResource(URL url, boolean useCaches)
    {
        if (url == null)
            return null;
        String urlString = url.toExternalForm();
        // context启动该时扫描加过file
        if (urlString.startsWith("file:"))
        {
            try
            {
                return new PathResource(url);
            }
            catch (Exception e)
            {
                if (LOG.isDebugEnabled())
                    LOG.warn("Bad PathResource: {}", url, e);
                else
                    LOG.warn("Bad PathResource: {} {}", url, e.toString());
                return new BadResource(url, e.toString());
            }
        }
        // 明显走的这个分支，在前面parseJarEntry方法中又加了一次前缀
        // jar包中的class文件~
        else if (urlString.startsWith("jar:file:"))
        {
            return new JarFileResource(url, useCaches);
        }
        // 纯jar包
        else if (urlString.startsWith("jar:"))
        {
            return new JarResource(url, useCaches);
        }

        return new URLResource(url, null, useCaches);
    }