第四章 Tomcat性能优化笔记

待我称王封你为后i 2021-11-17 11:56 371阅读 0赞

## **一、嵌入式Tomcat** ##

### **1、为什么要嵌入式** ###

为什么需要嵌入式启动，我们由之前一般的Tomcat启动可知，Tomcat组件非常多，启动流程步骤比较多，但是往往我们一般就只需要简单快速的部署一个Web项目，所以简单实用的嵌入式Tomcat就诞生而来。

**1.1、部署复杂度**

如果按照传统部署，我们需要下载Tomcat,同时需要配置服务器，同时还需要修改端口，同时也要避免应用系统的jar包与服务器中存在的lib包的冲突，所有的这些都会增加部署的复杂度，并且这种配置大部分还是一次性的，不可重用。如果你遇到大规模的服务器集群环境（部署N多个应用）时，会增加我们的运维成本，如果按照嵌入式启动，这种方式几乎是一键式的，可以把以上问题轻松的解决。

**1.2、架构约束**

Tomcat启动的时候默认不单单只启动了HTTP协议，还有AJP协议等等，如果我们就只想简简单单的启动一个HTTP服务，同时不想启动那些多组件，可以使用嵌入式Tomcat，避免在部署启动时的架构约束。

**1.3、微服务架构**

现在微服务已经是主流的架构，其中微服务中每项服务都拥有自己的进程并利用轻量化机制实现通讯。这些服务都是围绕业务功能建立，可以自动化部署或独立部署。将微服务架构与Tomcat技术相结合，可以轻松将系统部署到云服务器上。当前SpringBoot支持的嵌入式服务器组件就是Tomcat.

### **2、嵌入式启动实战** ###

**2.1、启动Servlet**

<dependency>
      <groupId>org.apache.tomcat.embed</groupId>
      <artifactId>tomcat-embed-core</artifactId>
      <version>8.5.34</version>
    </dependency>

ServletDemo.class

public class ServletDemo {
        public static void main(String[] args) throws Exception {
            //自定义的一个Servlet(专门处理http请求)
            HttpServlet httpServlet = new HttpServlet() {
                @Override
                public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
                    res.getWriter().write("hello world!");
                }
            };
            Tomcat tomcat = new Tomcat();  //引入嵌入式Tomcat
            Context context = tomcat.addContext("/demo",null); //部署应用的context
            tomcat.addServlet(context,"hello",httpServlet);//相当于往应用中添加Servlet
            context.addServletMappingDecoded("/hello","hello");  //相当于添加了servletMapping 映射信息
            tomcat.init(); //启动Tomcat  ---生命周期
            tomcat.start();
            tomcat.getServer().await();//用于阻塞Tomcat,等待请求过来
            //http://localhost:8080/demo/hello
        }
    }

启动后访问路劲：http://localhost:8080/demo/hello

通过实战可知，我们添加了一个HttpServlet提供对外服务，这样我们的Tomcat就可以简单的提供一个Servlet服务，而不提供页面访问（JSP、HTML等），可以非常灵活的控制Servlet的加载以及请求链接的分配，而不受限制于Context与应用的一一对应关系。

**2.2、嵌入式启动应用**

这个项目工程（ref-comet）是一个服务器推送的工程，包含了JSP

> **  
> <**dependency**>  
>   <**groupId**>org.apache.tomcat.embed</**groupId**>  
>   <**artifactId**>tomcat-embed-core</**artifactId**>  
>   <**version**>8.5.34</**version**>  
> </**dependency**>  
> **  
> <**dependency**>  
>   <**groupId**>org.apache.tomcat.embed</**groupId**>  
>   <**artifactId**>tomcat-embed-jasper</**artifactId**>  
>   <**version**>8.5.34</**version**>  
> </**dependency**>

// 要用嵌入式启动的方式启动一个SpringMVc的项目
     public class WebAppDemo {
        public static void main(String[] args) throws  Exception{
            Tomcat tomcat = new Tomcat();
            tomcat.addWebapp("/ref","D:\\work_tomcat\\ref-comet");
            tomcat.init();
            tomcat.start();
            tomcat.getServer().await();
        }
    }

启动访问：http://localhost:8080/ref/index

修改端口为80，增加代码：tomcat.getConnector().setPort(80);

启动访问：http://localhost/ref/index

看源码可知，Tomcat通过一个内部类DefaultWebXmlListener用来加载Web应用的配置。

Tomcat.class.addWebapp()方法：

public Context addWebapp(Host host, String contextPath, String docBase, LifecycleListener config) {
        this.silence(host, contextPath);
        Context ctx = this.createContext(host, contextPath);
        ctx.setPath(contextPath);
        ctx.setDocBase(docBase);
        ctx.addLifecycleListener(this.getDefaultWebXmlListener());
        ctx.setConfigFile(this.getWebappConfigFile(docBase, contextPath));
        ctx.addLifecycleListener(config);
        if (config instanceof ContextConfig) {
            ((ContextConfig)config).setDefaultWebXml(this.noDefaultWebXmlPath());
        }
        if (host == null) {
            this.getHost().addChild(ctx);
        } else {
            host.addChild(ctx);
        }
        return ctx;
    }

**2.3、嵌入式常用的配置**

setConnector：用于设置链接器，包括协议、I/0、端口、压缩、加密等等。

setHost：”用于设置Host。

setBaseDir：用于设置临时文件的目录，这些目录用于存放JSP生成的源代码及Class文件。

### **3、SpringBoot中使用嵌入式Tomcat** ###

没有用过SpringBoot的同学可以不看。

@SpringBootApplication
    public class DemoApplication {
        public static void main(String[] args) {
            // 启动内嵌的Tomcat，默认端口8080
            SpringApplication.run(DemoApplication.class, args);
        }
    }

SpringApplication.class

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
    }
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }

SpringApplication.class

public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();
        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            Banner printedBanner = this.printBanner(environment);
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class,
    
    new Class[]{ConfigurableApplicationContext.class}, context);
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            this.refreshContext(context); // tomcat本身就是容器
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }
        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }

private void refreshContext(ConfigurableApplicationContext context) {
        this.refresh(context);
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            } catch (AccessControlException var3) {
            }
        }
    }
    
    
    
    protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        ((AbstractApplicationContext)applicationContext).refresh();
    }
    
    
    
    public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);
    
            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {

EmbeddedWebApplicationContext.onRefresh()方法，注意springboot2.1.6最新版本没有这个类。

@Override
    protected void onRefresh() {
       super.onRefresh();
       try {
          createEmbeddedServletContainer();
       }catch (Throwable ex) {
          throw new ApplicationContextException("Unable to start embedded container", ex);
       }
    }

private void createEmbeddedServletContainer() {
       EmbeddedServletContainer localContainer = this.embeddedServletContainer;
       ServletContext localServletContext = getServletContext();
       if (localContainer == null && localServletContext == null) {
          EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
          this.embeddedServletContainer = containerFactory.getEmbeddedServletContainer(getSelfInitializer());
       }else if (localServletContext != null) {
          try {
             getSelfInitializer().onStartup(localServletContext);
          }catch (ServletException ex) {
             throw new ApplicationContextException("Cannot initialize servlet context",ex);
          }
       }
       initPropertySources();
    }
    
    To

mcatEmbeddedServletContainerFactory.class中Tomcat的内嵌实现代码如下：

@Override
    public EmbeddedServletContainer getEmbeddedServletContainer(ServletContextInitializer... initializers) {
       Tomcat tomcat = new Tomcat();
       File baseDir = (this.baseDirectory != null ? this.baseDirectory : createTempDir("tomcat"));
       tomcat.setBaseDir(baseDir.getAbsolutePath());
       Connector connector = new Connector(this.protocol);
       tomcat.getService().addConnector(connector);
       customizeConnector(connector);
       tomcat.setConnector(connector);
       tomcat.getHost().setAutoDeploy(false);
       configureEngine(tomcat.getEngine());
       for (Connector additionalConnector : this.additionalTomcatConnectors) {
          tomcat.getService().addConnector(additionalConnector);
       }
       prepareContext(tomcat.getHost(), initializers);
       return getTomcatEmbeddedServletContainer(tomcat);
    }

## **二、Tomcat性能优化** ##

### **1、server.xml优化** ###

其实网络的Tomcat配置信息的文章很多，五花八门，King老师一般推荐使用Tomcat自身提供的配置帮助文档，因为你只要下载了Tomcat,并且启动了它，那么Tomcat就会提供最官方，最准确的官方参数说明文档。下载Tomcat后不要删掉默认的程序包.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

一般Tomcat启动后，不改动端口的话，默认是8080,我们输入localhost:8080 访问下。

这个会出现一个英文的Tomcat环境界面，包括各种文档说明信息都在此，我推荐使用谷歌浏览器，因为这个浏览器自带翻译功能。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

**1.1、 Connector连接器**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

**1）****IO模型优化策略**

连接器模式改为NIO模式，NIO模式最大化压榨了CPU，把时间片更好利用起来，NIO适合大量长连接。

![20190730203906250.png][]

**2）****最大线程优化策略**

maxThreads属性设置为简单200.这对于单个核心计算机来说很好，但是可以根据生产计算机上的处理器数量[线性][Link 1]增加。在具有四个处理器的计算机上，将此值设置为800到1000之间的任何值都不会导致问题。如果配置的数量最终远远超过所需的线程数，则当服务器负载较低时，线程池将自然缩减此数字。

**3）****压缩gzip连接器传输**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4][]客户端和服务器之间的任何主要是文本的通信，无论是HTML，XML还是简单的Unicode，都可以使用简单的标准GZIP算法定期压缩高达90％。这可以对减少网络流量产生巨大影响，允许响应更快地发送回客户端，同时允许更多网络带宽可用于其他网络繁重的应用程序。

**1.2、配置线程池 Executor**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5][]

<Executor name="tomcatThreadPool"
        namePrefix="catalina-exec-" maxThreads="150"
        minSpareThreads="4" />
    
    
    <Connector  executor="tomcatThreadPool" port="8080" protocol="HTTP/1.1"
        connectionTimeout="20000" redirectPort="8443"
        minProcessors="5"
        maxProcessors="75"
        acceptCount="1000" />

**Executor的属性****：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6][]

**1.3、去除value访问tomcat记录**

关闭自动重载，热部署方式：

关闭自动重载，默认是true(不同版本中有差异),自动加载增加运行开销并且很容易内存溢出

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 8][]

### **2、web.xml优化** ###

去掉不必要的servlet： 如当前应用是REST应用(微服务)：

去掉不必要的资源：JspServlet，seesion也可以移除

JspServlet优化：

*  checkInterval - 如果“development”属性为false且“checkInterval”大于0，则使用后台编译。“checkInterval”是查看JSP页面(包括其附属文件)是否需要重新编译的两次检查时间间隔（单位：秒）。缺省值为0秒。
 *  classdebuginfo - 类文件在编译时是否显示调试(debugging)信息？ true 或false，缺省为true。
 *  classpath - 编译servlet时要使用的类路径，当ServletContext 属性org.apache.jasper.Constants.SERVLET\_CLASSPATH未设置的情况下，该参数才有效。在Tomcat中使用到Jasper时，该属性总被设置。缺省情况下，该路径基于你当前的web应用动态生成。
 *  compiler – Ant将要使用的JSP页面编译器，请查阅Ant文档获取更多信息。如果该参数未设置，那么默认的Eclipse JDT Java编译器将被用来代替Ant。没有缺省值。
 *  compilerSourceVM - 编译源文件时采用哪一个JDK版本？(缺省为 JDK 1.4)
 *  compilerTargetVM - 运行类文件时采用哪一个JDK版本？(缺省为 JDK 1.4)
 *  development - 是否让Jasper用于开发模式？如果是，检查JSPs修改的频率，将通过设置modificationTestInterval 参数来完成。true 或false，缺省为true。
 *  displaySourceFragment - 异常信息中是否包含出错的源代码片段？true 或false，缺省为true。
 *  dumpSmap - JSR45调试的SMAP信息是否转存到文件？true 或false，缺省为false。当suppressSmap 为true时，该参数为false。
 *  enablePooling - 确定是否共享标签处理器，true或false，缺省为true。
 *  engineOptionsClass - 允许指定的类来配置Jasper。如果没有指定，则使用默认的Servlet内置参数(EmbeddedServletOptions)。
 *  errorOnUseBeanInvalidClassAttribute - 在一个useBean action中，当类属性的值不是一个合法的bean class时，Jasper是否抛出异常？true或false，缺省为true。
 *  fork - 是否让Ant派生出JSP页面多个编译，它们将运行在一个独立于Tomcat的JVM上。true 或者false, 缺省为true.
 *  enStringAsCharArray - 是否把字符串转换为字符数组？在某些情况下会改善性能。缺省为false.
 *  eClassId - 当使用标签时，发送给Internet Explorer的class-id的值。缺省为：8AD9C840-044E-11D1-B3E9-00805F499D93。
 *  javaEncoding - 生成java源文件时采用的Java文件编码。缺省为UTF-8。
 *  keepgenerated - 是否保存每个页面生成的java源代码，而不删除。true 或 false，缺省为true。
 *  mappedfile - 是否对每个输入行都用一条print语句来生成静态内容，以方便调试。true 或 false，缺省为true。
 *  modificationTestInterval - 检查JSP页面修改的间隔时间（单位：秒），在间隔时间内，JSP及其包含的页面将不会检查。当间隔时间为0时，JSP每一次访问都会被检查。仅仅适用于开发模式（参数development为true）。缺省为4秒。从JSP每次开始访问开始计时，N秒以后检查，变化就编译，每次访问都刷新开始时间，默认4秒
 *  scratchdir - 当编译JSP页面时使用的scratch 目录。缺省为当前WEB应用的工作目录。
 *  suppressSmap - 是否禁止JSR45调试时生成SMAP信息？true 或 false，缺省为false。
 *  trimSpaces - 是否去掉模板文本中行为和指令之间的空格。缺省为false。
 *  xpoweredBy - 确定生成的Servlet是否加上X-Powered-By 响应头？true 或 false，缺省为false。

### **3、Tomcat常见问题解决** ###

Tomcat版本升级

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 10][]

## **三、Tomcat常见面试题** ##

### **1、Tomcat有哪几种部署方式？** ###

**1.1、隐式部署**

直接丢文件夹、war、jar到webapps目录，tomcat会根据文件夹名称自动生成虚拟路径，简单，但是需要重启Tomcat服务器，包括要修改端口和访问路径的也需要重启。

**1.2、显式部署**

**1）****添加****context****元素****：**

server.xml中的Host加入一个Context（指定路径和文件地址），例如：

> <Host name="localhost">
> 
> <Context path="/comet" docBase="D:\\work\_tomcat\\ref-comet.war" />

即/comet 这个虚拟路径映射到了D:\\work\_tomcat\\ref-comet目录下(war会解压成文件)，修改完servler.xml需要重启tomcat 服务器。

**2）创建xml文件**

在conf/Catalina/localhost中创建xml文件，访问路径为文件名，例如：

在localhost目录下新建demo.xml，内容为：

> <Context docBase="D:\\work\_tomcat\\ref-comet" />

不需要写path，虚拟目录就是文件名demo，path默认为/demo，添加demo.xml不需要重启 tomcat服务器。

**3）****三种方式比较：**

隐式部署：可以很快部署,需要人手动移动Web应用到webapps下，在实际操作中不是很人性化

添加context元素 : 配置速度快,需要配置两个路径，如果path为空字符串，则为缺省配置,每次修改server.xml文件后都要重新启动Tomcat服务器，重新部署.

创建xml文件:服务器后台会自动部署，修改一次后台部署一次，不用重复启动Tomcat服务器,该方式显得更为智能化。

### **2、Tomcat核心组件是哪些？** ###

Tomcat的核心组件是链接器(connector)和容器(Container)，

链接器(connector)封装了底层的网络请求(Socket请求及相应处理),提供了统一的接口.

容器(Container)则专注处理Servlet，Tomcat本质上就是Servlet容器。

### **3、什么是Tomcat的Valve** ###

在一个大的组件中直接处理这些繁杂的逻辑处理,使用管道（pipeline）可以把把多个对象连接起来，而Valve(阀门)整体看起来就像若干个阀门嵌套在管道中，而处理逻辑放在阀门上。

管道(Pipeline)就像一个工厂中的生产线，负责调配工人（valve）的位置，valve则是生产线上负责不同操作的工人。

### **4、Tomcat 有哪几种Connector 运行模式(优化)？** ###

*  bio(blocking I/O)  同步阻塞I/O （tomcat8.5版本已经移除）
 *  nio(non-blocking I/O)  同步非阻塞I/O
 *  Nio2/AIO   异步非阻塞I/0
 *  apr(Apache Portable Runtime/Apache可移植运行库)

对于I/0选择，要根据业务场景来定，一般高并发场景下，APR和NIO2的性能要优于NIO和BIO，（linux操作系统支持的NIO2由于是一个假的，并没有真正实现AIO，所以一般linux上推荐使用NIO，如果是APR的话，需要安装APR库，而Windows上默认安装了），所以在8.5的版本中默认是NIO。

### **5、tomcat容器是如何创建servlet类实例？用到了什么原理？** ###

当容器启动时，会读取在webapps目录下所有的web应用中的web.xml文件，然后对xml文件进行解析，并读取servlet注册信息。然后，将每个应用中注册的servlet类都进行加载，并通过反射的方式实例化（也有可能是在第一次请求时实例化）。

### **6、tomcat 如何优化？** ###

### **7、tomcat 中JVM如何调优** ###

一般我们优化启动时的堆内存设置,Windows下,在文件\{tomcat\_home\}/bin/catalina.bat，Unix下，在文件$CATALINA\_HOME/bin/catalina.sh的前面，增加如下设置：

JAVA\_OPTS=”‘$JAVA\_OPTS” -Xms\[初始化内存大小\] -Xmx\[可以使用的最大内存\]

一般说来，你应该使用物理内存的 80% 作为堆大小。建议设置为70％；建议设置\[\[初始化内存大小\]等于\[可以使用的最大内存\]，这样可以减少平凡分配堆而降低性能。

### **8、说出Tomcat中用到的任意一种设计模式？** ###

### **9、Tomcat中类加载的顺序** ###

当应用需要到某个类时，则会按照下面的顺序进行类加载：

*  使用bootstrap引导类加载器加载
 *  使用system系统类加载器加载
 *  使用应用类加载器在WEB-INF/classes中加载
 *  使用应用类加载器在WEB-INF/lib中加载
 *  使用common类加载器在CATALINA\_HOME/lib中加载

### **10、什么是双亲委派模型？** ###

**定义：**双亲委派模型的工作过程为：如果一个类加载器收到了类请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父加载器去完成，每一层都是如此，因此所有类加载的请求都会传到启动类加载器，只有当父加载器无法完成该请求时，子加载器才去自己加载。

**实现方式：**该模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。子类加载器不是以继承的关系来实现，而是通过组合关系来复用父加载器的代码。

**意义：**好处双亲委派模型的好处就是java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如：Object,无论那个类加载器去加载该类，最终都是由启动类加载器进行加载的，因此Object类在程序的各种类加载环境中都是一个类。如果不用改模型，那么java.lang.Object类存放在classpath中，那么系统中就会出现多个Object类，程序变得很混乱。

### **11、既然 Tomcat 不遵循双亲委派机制，那么如果我自己定义一个恶意的HashMap，会不会有风险呢？** ###

不会有风险，如果有，Tomcat都运行这么多年了，那群Tomcat大神能不改进吗？ tomcat不遵循双亲委派机制，只是自定义的webAppclassLoader不遵循，但上层的类加载器还是遵守双亲委派的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: /images/20211116/27d300423e6e4b388581248a11151c8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: /images/20211116/f27e5ebfb00547138296afaffc67eabe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2]: /images/20211116/6dcd3b0b9c574192858b42b255ce0990.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3]: /images/20211116/987f61d88fd84ca0a78abb28c2e4027a.png
[20190730203906250.png]: /images/20211116/4ef50f46650e42268e7033f7485734cb.png
[Link 1]: https://www.theserverside.com/feature/Why-Java-Applications-Fail-to-Scale-Linearly
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4]: /images/20211116/99ef7dc435494d15b6913ee8bec2cae5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5]: /images/20211116/95c109fc5d0943e09c0bc988e7c83177.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6]: /images/20211116/570ee866063a445abf51a5bcbb38edc5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 7]: /images/20211116/8c27bb48830e400cb29be01025a3bb8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 8]: /images/20211116/f8cf4e5328b5460d8a74bfd63d29bd47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 9]: /images/20211116/954bd25d9bf546fbae3735bddbc11e16.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 10]: /images/20211116/6f67f00b388f4be2ab305eb20ac57d7b.png