下载文档原格式
tomcat基本架构Tomcat基本架构简介在现代互联网应用中，Tomcat（Apache Tomcat）被广泛使用作为Java Servlet 容器来运行和管理Java Web应用程序。
作为一个开源项目，Tomcat提供了一个可靠、高效的环境来部署和托管Java Web应用。
本文将深入介绍Tomcat 的基本架构，包括它的组成部分、工作原理和核心功能。
一、组成部分Tomcat基于Java技术实现，由多个组件构成，这些组件共同协作，以提供完整的Web服务器功能。
以下是Tomcat的主要组成部分：1. Catalina：Catalina是Tomcat的核心组件之一，负责管理和执行Servlet的生命周期。
它包含了一个Coyote容器用于处理HTTP请求，并通过调用适当的Servlet来生成HTTP响应。
2. Coyote：Coyote是Tomcat的通信组件，用于将HTTP请求转发给Catalina 容器进行处理。
它负责处理底层的网络通信，包括解析HTTP请求和生成HTTP 响应。
3. Jasper：Jasper是Tomcat的JSP引擎，用于将JSP文件编译成Java源文件，并最终生成对应的Servlet类。
它提供了JSP的运行时环境，使得Tomcat能够处理和执行JSP页面。
4. Cluster：Tomcat的Cluster组件用于实现集群部署，即可以将多个Tomcat 服务器连接在一起，共同处理和管理Web应用。
它提供了负载均衡和会话复制等功能，确保Web应用的高可用性和可扩展性。
5. Manager：Manager组件用于管理Tomcat中的Web应用。
它提供了一组Web界面，可以通过这些界面来管理和监控已部署的Web应用，包括启动、停止、重新部署等操作。
二、工作原理Tomcat的工作原理可以简单概括为以下几个步骤：1. 接受HTTP请求：当Tomcat服务器启动后，Coyote组件会监听指定的端口，等待客户端发起HTTP请求。
tomcat实现原理Tomcat是一种流行的Web服务器和Servlet容器，它可以运行Java Servlet和JavaServer Pages (JSP)应用程序。
Tomcat实现的原理是基于Java Servlet规范和JavaServer Pages规范的。
Tomcat的架构Tomcat的架构由三个主要的组件组成：连接器，容器和处理器。
连接器是Tomcat与客户端之间的通信协议，它可以处理HTTP、HTTPS、AJP、JMX等多种协议。
容器是Tomcat的核心组件，它管理着所有的Servlet和JSP的生命周期。
处理器则是Tomcat中的工作线程，它负责处理客户端请求和响应。
Tomcat的启动流程当Tomcat启动时，它会执行以下步骤：1. 加载配置文件：Tomcat会加载server.xml、web.xml等配置文件，这些文件中包含了Tomcat的配置信息，如监听端口、上下文路径等。
2. 初始化连接器：Tomcat会根据配置文件中的信息初始化连接器，连接器负责处理客户端请求，它会监听指定的端口，并根据协议类型处理不同的请求。
3. 初始化容器：Tomcat会为每个Web应用程序初始化一个容器，容器负责管理Servlet和JSP的生命周期，它会加载指定的Servlet和JSP，并将它们实例化。
4. 初始化处理器：Tomcat会初始化一定数量的处理器，处理器负责处理客户端请求和响应，它们会从连接器中获取请求，然后将请求交给对应的容器去处理。
5. 接受客户端请求：当Tomcat启动完成后，它会一直监听客户端请求，并通过连接器将请求发送给处理器。
6. 处理客户端请求：处理器会根据请求的信息，找到对应的容器和Servlet或JSP，然后调用它们的相应方法处理请求，并生成响应。
7. 发送响应：处理器会将响应发送给客户端，然后关闭连接。
Tomcat的工作原理Tomcat在处理客户端请求时，采用了多线程的方式，即每个请求都会分配一个线程来处理。
tomcat线程池原理
Tomcat线程池是Tomcat容器提供的一种管理线程池的工具, 可以有效地处理多线程和多用户请求.
Tomcat线程池通过预先创建并缓存线程, 以便在用户访问时不必重复创建新的线程, 而是可以立即响应用户请求.
Tomcat线程池由两个部分组成:
1. 一个线程池管理器来管理线程池
2. 一个线程池用于管理Tomcat容器中的线程
Tomcat线程池的工作原理:
1. 线程池管理器从客户端接收用户请求并处理它们
2. 管理器将每个新用户请求放入线程池中
3. 如果线程池中有可用线程, 则用可用线程处理请求, 否则将其加入队列中, 等待空闲线程
4. 当有空闲线程的时候, 线程池管理器将接收到的用户请求队列释放一个线程来处理请求
5. 当线程处理完用户请求后, 管理器释放该线程, 并将其放回线程池中, 供之后的用户请求使用
6. 当线程池管理器检测到空闲线程数量超过一定值时, 将自动删除多余的线程, 以节省系统资源.。
tomcat 并发原理Tomcat是一个流行的Java Web服务器，它使用Java Servlet和JavaServer Pages（JSP）技术来提供Web应用程序的服务。
Tomcat的并发原理是如何处理多个请求并同时响应它们的问题。
Tomcat的并发处理是通过线程池来实现的。
当Tomcat启动时，它会创建一个线程池，该线程池包含一组可用的线程。
当有请求到达Tomcat时，Tomcat会从线程池中获取一个可用的线程来处理该请求。
如果线程池中没有可用的线程，则Tomcat会等待，直到有线程可用为止。
Tomcat的线程池大小可以通过配置文件进行设置。
如果线程池太小，Tomcat可能无法处理所有的请求，导致请求被阻塞或超时。
如果线程池太大，Tomcat会消耗过多的内存和CPU资源，导致性能下降。
Tomcat还使用了一种称为NIO（Non-blocking I/O）的技术来提高并发性能。
NIO允许Tomcat在单个线程中处理多个请求。
这种技术可以减少线程的创建和销毁，从而提高性能和可伸缩性。
Tomcat还使用了一种称为异步Servlet的技术来提高并发性能。
异步Servlet允许Tomcat在处理请求时不必等待响应，而是可以继续处理其他请求。
这种技术可以减少线程的使用，从而提高性能和可伸缩性。
总的来说，Tomcat的并发处理是通过线程池、NIO和异步Servlet等技术来实现的。
这些技术可以提高Tomcat的性能和可伸缩性，从而更好地处理多个请求并同时响应它们。
在实际应用中，为了更好地处理并发请求，我们可以采取以下措施：1.合理设置线程池大小，避免线程池过小或过大导致性能下降。
2.使用NIO技术来提高并发性能，减少线程的创建和销毁。
3.使用异步Servlet技术来提高并发性能，减少线程的使用。
4.使用缓存技术来减少对数据库的访问，提高性能。
5.使用负载均衡技术来分散请求，避免单个Tomcat服务器负载过重。
Tomcat APR 原理详解什么是 Tomcat APRTomcat APR（Apache Portable Runtime）是一个用于提高 Tomcat 性能的组件。
它是由 Apache 软件基金会开发的，是一个跨平台的库，提供了一套 API，用于访问操作系统底层的功能和特性。
Tomcat APR 可以与 Tomcat 一起使用，以提高其性能和可靠性。
Tomcat APR 的基本原理Tomcat APR 的基本原理是利用操作系统底层的功能和特性来提高 Tomcat 的性能和可靠性。
它通过以下几个方面来实现：1. 使用本地线程池Tomcat APR 使用本地线程池来处理客户端请求。
本地线程池是一种特殊的线程池，它使用操作系统底层的线程来处理请求，而不是使用 Java 虚拟机的线程。
这样可以减少线程切换的开销，提高请求处理的效率。
2. 使用异步 I/OTomcat APR 使用异步 I/O 来处理客户端请求。
异步 I/O 是一种非阻塞的 I/O 模型，它允许应用程序在等待 I/O 操作完成时继续处理其他任务，而不是阻塞在I/O 操作上。
这样可以提高请求处理的并发能力。
3. 使用内存池Tomcat APR 使用内存池来管理内存的分配和释放。
内存池是一种高效的内存管理机制，它可以减少内存分配和释放的开销，提高内存的使用效率。
Tomcat APR 使用操作系统底层的内存池来管理内存，而不是使用 Java 虚拟机的内存管理机制。
4. 使用本地套接字Tomcat APR 使用本地套接字来处理网络通信。
本地套接字是一种特殊的套接字，它使用操作系统底层的网络协议栈来处理网络通信，而不是使用 Java 虚拟机的网络协议栈。
这样可以减少网络通信的开销，提高网络通信的效率。
5. 使用本地 SSL 加速Tomcat APR 使用本地 SSL 加速来提高 SSL/TLS 协议的性能。
本地 SSL 加速是一种特殊的加速机制，它使用操作系统底层的 SSL/TLS 实现来加速 SSL/TLS 协议的处理，而不是使用 Java 虚拟机的 SSL/TLS 实现。
tomcat 线程池连接池指标Tomcat线程池连接池指标一、引言随着互联网的快速发展，Web应用程序的并发访问量越来越大，为了提高应用程序的性能和响应速度，使用线程池成为了一种常见的解决方案。
而在Tomcat中，线程池连接池则是实现这一目标的重要组成部分。
本文将围绕Tomcat线程池连接池的指标展开论述，以便读者能够更好地了解和应用这一技术。
二、线程池连接池的概念线程池连接池是Tomcat中的一种机制，用于管理和复用线程和数据库连接资源，以提高应用程序的并发处理能力和性能。
通过线程池连接池，可以有效地减少线程的创建和销毁开销，降低数据库连接和释放的成本，从而提高系统的吞吐量和响应速度。
三、Tomcat线程池连接池的指标1. 最大线程数（maxThreads）最大线程数表示线程池中最多可以同时运行的线程数量。
根据应用程序的并发访问量和服务器的硬件配置，合理设置最大线程数可以充分利用服务器资源，避免因线程不足而导致的请求被阻塞或拒绝。
2. 空闲线程数（minSpareThreads）空闲线程数表示线程池中保留的空闲线程数量。
通过设置适当的空闲线程数，可以避免线程池中的线程过多而导致资源浪费，同时又能保证在高并发情况下能够快速响应请求。
3. 连接池大小（maxConnections）连接池大小表示连接池中可用的数据库连接数量。
根据应用程序对数据库的访问需求和数据库服务器的性能，合理设置连接池大小可以避免因连接不足而导致的请求被阻塞或拒绝。
4. 最大等待时间（maxWait）最大等待时间表示当连接池已满时，请求线程最多等待的时间。
如果超过最大等待时间仍未获取到可用的数据库连接，系统将抛出异常或拒绝请求。
合理设置最大等待时间可以避免请求线程长时间被阻塞，提高系统的稳定性和可用性。
5. 连接超时时间（connectionTimeout）连接超时时间表示获取数据库连接的最长等待时间。
如果超过连接超时时间仍未获取到连接，系统将抛出异常或拒绝请求。
很多开源应用服务器都是集成tomcat作为web container的，而且对于tomcat 的servlet container这部分代码很少改动。
这样，这些应用服务器的性能基本上就取决于Tomcat处理HTTP请求的connector模块的性能。
本文首先从应用层次分析了tomcat所有的connector种类及用法，接着从架构上分析了connector 模块在整个tomcat中所处的位置，最后对connector做了详细的源代码分析。
并且我们以Http11NioProtocol为例详细说明了tomcat是如何通过实现ProtocolHandler接口而构建connector的。
通过本文的学习，应该可以轻松做到将tomcat做为web container集成到第三方系统，并且自定义任何你想要的高性能的HTTP连接器1 Connector介绍1.1 Connector的种类Tomcat源码中与connector相关的类位于org.apache.coyote包中，Connector 分为以下几类：∙Http Connector, 基于HTTP协议，负责建立HTTP连接。
它又分为BIO Http Connector与NIO Http Connector两种，后者提供非阻塞IO与长连接Comet支持。
∙AJP Connector, 基于AJP协议，AJP是专门设计用来为tomcat与http 服务器之间通信专门定制的协议，能提供较高的通信速度和效率。
如与Apache服务器集成时，采用这个协议。
∙APR HTTP Connector, 用C实现，通过JNI调用的。
主要提升对静态资源（如HTML、图片、CSS、JS等）的访问性能。
现在这个库已独立出来可用在任何项目中。
Tomcat在配置APR之后性能非常强劲。
1.2 Connector的配置对Connector的配置位于conf/server.xml文件中。
在Tomcat 9中，线程池（Thread Pool）的配置是通过`<Executor>`元素在`server.xml`文件中进行的。
线程池允许你为Tomcat的HTTP/1.1 Connector定义一个共享的线程池，这样可以提高性能，尤其是在高并发的环境中。
以下是一个配置线程池的示例：```xml<Executor name="tomcatThreadPool"namePrefix="tomcatThreadPool-"maxThreads="1000"maxIdleTime="300000"minSpareThreads="200"threadPriority="5" />```这里的关键参数说明如下：- `name`：线程池的唯一标识符。
默认值为`None`，但为了能够引用这个线程池，你应该给它一个名字。
- `namePrefix`：每个线程的名称前缀。
默认值是`tomcat-exec-`。
- `maxThreads`：线程池中允许的最大线程数。
默认值是200。
- `maxIdleTime`：在关闭一个空闲线程之前，允许它保持空闲的时间（以毫秒为单位）。
默认值是60000（一分钟）。
- `minSpareThreads`：始终保持的最小空闲线程数。
默认值是25。
- `threadPriority`：线程的优先级。
默认值是5。
在配置了线程池之后，你需要在`<Connector>`元素中引用这个线程池：```xml<Connector executor="tomcatThreadPool"port="8080"protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8443"minProcessors="5"maxProcessors="75"acceptCount="1000" />```这里的关键参数说明如下：- `executor`：指定要使用的线程池的名称。
tomcat 并发原理Tomcat并发原理Tomcat是一个开源的Java Web服务器，用于运行Java Servlet和JavaServer Pages（JSP）的容器。
它是Apache软件基金会的一个开源项目，被广泛用于构建和部署Java Web应用程序。
在Tomcat的运行过程中，它需要处理大量的并发请求，以保证Web应用程序的高性能和稳定性。
本文将介绍Tomcat的并发原理，包括Tomcat的线程模型、请求处理流程以及并发控制方法。
1. 线程模型Tomcat采用了多线程的模型来处理并发请求。
在Tomcat启动时，它会创建一组线程池，用于处理客户端请求。
每个线程都可以独立处理一个请求，并在请求处理完成后返回线程池，以便处理其他请求。
这种线程池的设计可以有效地利用系统资源，提高并发处理能力。
2. 请求处理流程当Tomcat接收到一个客户端请求时，它会从线程池中选取一个空闲的线程来处理该请求。
线程会负责解析请求、执行Servlet或JSP，并生成响应结果。
在处理请求的过程中，Tomcat会保持与客户端的连接，以便及时发送响应数据。
当请求处理完成后，Tomcat会将线程返回线程池，以便处理其他请求。
3. 并发控制方法为了保证Tomcat能够处理大量的并发请求，我们需要对并发进行合理的控制。
以下是几种常见的并发控制方法：a. 增加线程池大小：通过增加线程池的大小，可以增加Tomcat处理并发请求的能力。
但是过大的线程池可能会消耗过多的系统资源，导致系统性能下降，所以需要根据实际情况进行调整。
b. 使用线程池队列：当线程池中的线程都在处理请求时，新的请求可以加入到线程池的队列中等待处理。
这样可以避免请求被丢失，并且可以控制并发请求的数量。
c. 限制最大并发数：通过限制最大并发数，可以防止过多的请求同时进入系统。
可以根据系统的处理能力和负载情况来设置最大并发数，以避免系统过载。
d. 使用非阻塞IO：Tomcat 7及以上版本引入了非阻塞IO模型，可以更好地处理高并发请求。
tomcat工作原理深入详解目录一、Tomcat简介 (3)1.1 Tomcat的历史与发展 (4)1.2 Tomcat的应用领域 (5)1.3 Tomcat的特点与优势 (6)二、Tomcat的工作模式 (8)2.1 Tomcat作为Servlet容器 (10)2.2 Tomcat作为Web服务器 (12)2.3 Tomcat作为应用服务器 (14)三、Tomcat的架构分析 (15)3.1 Tomcat的整体架构 (16)3.2 Tomcat的模块组成 (17)3.3 Tomcat的架构扩展性 (19)四、Tomcat的启动与关闭 (21)4.1 Tomcat的启动过程 (22)4.2 Tomcat的关闭过程 (23)4.3 Tomcat的运行时参数配置 (25)五、Tomcat的线程管理 (26)5.1 Tomcat的线程模型 (27)5.2 Tomcat的线程池管理 (29)5.3 Tomcat的线程安全问题 (30)六、Tomcat的请求处理流程 (32)6.1 请求到达Tomcat的路径 (33)6.2 请求在Tomcat内部的流转 (35)6.3 响应在Tomcat内部的生成与返回 (36)七、Tomcat的集群与负载均衡 (38)7.1 Tomcat的集群模式 (40)7.2 负载均衡的策略与实现 (41)7.3 集群与负载均衡的性能优化 (42)八、Tomcat的安全管理 (44)8.1 Tomcat的安全漏洞 (46)8.2 Tomcat的安全配置 (48)8.3 Tomcat的安全防护措施 (49)九、Tomcat的性能优化 (51)9.1 Tomcat的性能监控 (54)9.2 Tomcat的性能调优 (55)9.3 Tomcat的性能瓶颈分析与解决 (57)十、Tomcat的日志分析 (57)10.1 Tomcat的日志种类与作用 (58)10.2 Tomcat的日志分析工具 (60)10.3 Tomcat的日志分析与优化建议 (62)十一、总结与展望 (64)11.1 Tomcat的工作原理总结 (64)11.2 Tomcat的发展趋势与未来展望 (66)一、Tomcat简介Apache Tomcat 是一个开源的 Java Servlet 容器，它实现了Java Servlet、JavaServer Pages（JSP）、Java Expression Language 和 Java WebSocket 技术规范。
Tomcat线程池实现简介目前市场上常用的开源Java Web容器有Tomcat、Resin和Jetty。
其中Resin从V3.0后需要购买才能用于商业目的，而其他两种则是纯开源的。
可以分别从他们的网站上下载最新的二进制包和源代码。
作为Web容器，需要承受较高的访问量，能够同时响应不同用户的请求，能够在恶劣环境下保持较高的稳定性和健壮性。
在HTTP服务器领域，Apache HTTPD的效率是最高的，也是最为稳定的，但它只能处理静态页面的请求，如果需要支持动态页面请求，则必须安装相应的插件，比如mod_perl可以处理Perl脚本，mod_python可以处理Python脚本。
上面介绍的三中Web容器，都是使用Java编写的HTTP服务器，当然他们都可以嵌到Apache 中使用，也可以独立使用。
分析它们处理客户请求的方法有助于了解Java多线程和线程池的实现方法，为设计强大的多线程服务器打好基础。
Tomcat是使用最广的Java Web容器，功能强大，可扩展性强。
最新版本的Tomcat（5.5.17）为了提高响应速度和效率，使用了Apache Portable Runtime（APR）作为最底层，使用了APR 中包含Socket、缓冲池等多种技术，性能也提高了。
APR也是Apache HTTPD的最底层。
可想而知，同属于ASF（Apache Software Foundation）中的成员，互补互用的情况还是很多的，虽然使用了不同的开发语言。
Tomcat 的线程池位于tomcat-util.jar文件中，包含了两种线程池方案。
方案一：使用APR 的Pool技术，使用了JNI；方案二：使用Java实现的ThreadPool。
这里介绍的是第二种。
如果想了解APR的Pool技术，可以查看APR的源代码。
ThreadPool默认创建了5个线程，保存在一个200维的线程数组中，创建时就启动了这些线程，当然在没有请求时，它们都处理“等待”状态（其实就是一个while循环，不停的等待notify）。
如果有请求时，空闲线程会被唤醒执行用户的请求。
具体的请求过程是：服务启动时，创建一个一维线程数组（maxThread＝200个），并创建空闲线程(minSpareThreads＝5个)随时等待用户请求。
当有用户请求时，调用threadpool.runIt(ThreadPoolRunnable)方法，将一个需要执行的实例传给ThreadPool中。
其中用户需要执行的实例必须实现ThreadPoolRunnable接口。
ThreadPool 首先查找空闲的线程，如果有则用它运行要执行ThreadPoolRunnable；如果没有空闲线程并且没有超过maxThreads，就一次性创建minSpareThreads个空闲线程；如果已经超过了maxThreads了，就等待空闲线程了。
总之，要找到空闲的线程，以便用它执行实例。
找到后，将该线程从线程数组中移走。
接着唤醒已经找到的空闲线程，用它运行执行实例（ThreadPoolRunnable）。
运行完ThreadPoolRunnable后，就将该线程重新放到线程数组中，作为空闲线程供后续使用。
由此可以看出，Tomcat的线程池实现是比较简单的，ThreadPool.java也只有840行代码。
用一个一维数组保存空闲的线程，每次以一个较小步伐（5个）创建空闲线程并放到线程池中。
使用时从数组中移走空闲的线程，用完后，再“归还”给线程池。
ThreadPool提供的仅仅是线程池的实现，而如何使用线程池也是有很大学问的。
让我们看看Tomcat是如何使用ThreadPool的吧。
Tomcat有两种EndPoint，分别是AprEndpoint和PoolTcpEndpoint。
前者自己实现了一套线程池（其实这和Tomcat 老版本的方案是相同的，至今Tomcat中还保留着老版本的线程池，PoolTcpEndpoint也有类似的代码，通过“策略”可以选择不同的线程池方案）。
我们只关注PoolTcpEndpoint如何使用ThreadPool的。
首先，PoolTcpEndpoint创建了一个ThreadPoolRunnable实例——LeaderFollowerWorkerThread，实际上该实例就是接收（Accept）并处理（Process）用户socket 请求。
接着将该实例放进ThreadPool中并运行，此时就可以接收用户的请求了。
当有Socket请求时，LeaderFollowerWorkerThread首先获得了Socket实例，注意此时LeaderFollowerWorkerThread并没有急着处理该Socket，而是在响应Socket消息前，再次将LeaderFollowerWorkerThread放进ThreadPool中，从而它（当然是另外一个线程了）可以继续处理其他用户的Socket 请求；接着，拥有Socket的LeaderFollowerWorkerThread再来处理该用户的Socket请求。
整个过程与传统的处理用户Socket请求是不同的，也和Tomcat老版本不同。
传统的处理方法是：有一个后台运行的监听线程负责统一处理接收（注意只是“接收”）Socket请求，当有新的Socket请求时，将它赋值给一个Worker线程（通常是唤醒该线程），并有后者处理Socket请求，监听线程继续等待其他Socket请求。
所以整个过程中有一个从Listener到Worker 切换的过程。
而新版本Tomcat很有创造性的使用了另外一种方法，正如前文所描述的，接收和处理某个用户Socket请求的始终是由一个线程全程负责，没有切换到其他线程处理，少了这种线程间的切换是否更有效率呢？我还不能确认。
不过这种使用方式确实有别于传统模式，有种耳目一新的感觉。
除了Tomcat外，Jetty是另外一个重要的Java Web容器，号称“最小的”Web容器，从Jetty 的源代码规模可以看出它确实比较小。
而且它的ThreadPool的实现也非常简单，整个代码ThreadPool代码只有450行左右，可见小巧之极。
ThreadPool代码位于com.mortbty.thread包中，其中最重要的方法是dispatch（）和内部类PoolThread。
顾名思义，dispatch方法主要是将Runnable实例派给线程池中的空闲PoolThread，由后者运行Runnable。
还是看看整个过程吧。
首先，ThreadPool创建_minThreads个空闲PoolThread，并把它们添加到空闲线程队列中。
当需要运行Runnable时，首先查找是否有空闲的PoolThread，如果有空闲的，这由它处理；如果没有并且PoolThread并没有超过_maxThreads个时，则创建一个新的PoolThread，并由这个新创建的PoolThread运行Runnable；如果PoolThread超过了_maxThreads，则一直等待有空闲的PoolThread出现。
在PoolThread运行之前，必须把该PoolThread从空闲线程队列中移走。
再来看看PoolThread的实现吧。
和所有的Worker线程一样，用一个while（flag）{wait();}循环等待Runnable的到来，当有Runnable被ThreadPool.dispatch（）时，该PoolThread就运行Runnable；当运行完成后，再“归还”给空闲线程队列。
Jetty如何使用ThreadPool？整个Jetty只使用了一个ThreadPool实例，具体入口在org.mortbay.jetty.Server中被实例化的，Connector中也使用Server的ThreadPool处理用户的Socket 请求。
Connector是处理用户Socket请求的入口，一个Connector创建_acceptors个Acceptor，由Acceptor处理用户Socket 请求时，当有Socket请求时，就创建一个Connection放到线程池中处理，而Acceptor继续处理其他的Socket请求。
这是个传统的Listener和Worker处理方式。
在这些Java Web容器中，Resin算得上很特别的，小巧稳定，而且效率很高。
在这些Java Web 容器中，算它的效率最高了。
很多大型的网站中都能找到它的身影。
Resin从3.0版本后开始走“特色”的开源路，与MySql很相似——如果用于商业目的，则需要买它的License。
但对于个人研究而言，这已经不错了，在网站上可以下载除了涉及License的源代码外其他所有代码。
说Resin特别，还主要是由于它的性能出众，即使在很多企业级应用中也能派上用场。
Resin 的数据库连接池做的很不错，效率非常高。
不过这里我们讨论它的线程池，看看有何特别之处。
Resin的ThreadPool位于com.caucho.util.ThreadPool中，不过这个类的命名有点蹊跷，更恰当的命名是ThreadPoolItem，因为它确实只是一个普通的Thread。
那线程调度何管理在哪里呢？也在这个类中，不过都是以静态函数方式提供的，所以这个类起到了两重作用：线程池调度和Worker线程。
也由于这种原因，Resin实例中只有一个线程池，不像Tomcat和Jetty 可以同时运行多个线程池，不过对于一个系统而言，一个线程池足够了。
和其他线程池实现方式不同的是，Resin采用链表保存线程。
如果有请求时，就将Head移走并唤醒该线程；待运行完成后，该线程就变成空闲状态并且被添加到链表的Head部分。
另外，每一个线程运行时都要判断当前空闲线程数是否超过_minSpareThreads，如果超过了，该线程就会退出（状态变成Dead），也从链表中删除。
Resin如何使用该ThreadPool？所有需要用线程池的地方，只需调用ThreadPool. Schedule(Runnable)即可。
该方法就是一个静态函数，顾名思义，就是将Runnable加到ThreadPool中待运行。
Resin使用的还是传统方法：监听线程（com.caucho.server.port.Port）,系统中可以有多个Port 实例，前提端口号不同，比如有80和8080端口；另外就是Worker线程，其实就是ThreadPool 中的空闲线程。
Port本身是一个Thread，在启动时，会在ThreadPool中运行5个线程——TcpConnection同时等待用户请求，当有用户请求时，其中的一个会处理。
