tomcat安装及优化

tomcat

概念

什么是Tomcat

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器, 按照Sun提供的技术规范，实现了对Servlet和Java Server Page（JSP）的支持，使用HTTP或https协议与客户端（通常是浏览器）进行通信。

Tomcat 和 apache、nginx 等 Web 服务器一样，具有处理 HTML 页面的功能。不过，Tomcat 处理静态 HTML 的能力不如 Apache和nginx 服务器。

Web server只能完成静态资源的请求；

Servlet 容器能够进行动态资源的请求；

官方网站：http://tomcat.apache.org/

了解jsp

JSP：全名为Java Server Pages，中文名叫java服务器页面，是一种动态网页开发技术。JSP技术是在传统的网页HTML（文件(*.htm,*.html)中插入Java程序和JSP标记(tag)，从而形成JSP文件，后缀名为(*.jsp)。用JSP开发的Web应用是跨平台的，既能在Linux下运行，也能在其他操作系统上运行。

支持 JSP 网站，收费版 web 服务器：oracle 的 weblogic；IBM 的 websphere。

了解servlet

　Servlet（Server Applet）是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，主要功能在于交互式地浏览和修改数据，生成动态Web内容。

Servlet架构，在软件里面位置如下：

这个过程为：

客户端发送请求至服务器端；
服务器将请求信息发送至 Servlet；
Servlet 生成响应内容并将其传给服务器；
服务器将响应返回给客户端。

了解java

JDK : java development kit (套件) 。

JDK(Java Development Kit) 是 Java 语言的软件开发工具包(SDK)。简单的说 JDK 是面向开发人员使用的 SDK，它提供了 Java的开发环境和运行环境。就是Java开发工具，是进行Java开发的基础。JDK 是整个Java的核心，包括了Java运行环境，Java工具和Java基础的类库。

JDK有三个版本，分别是：

SE(JavaSE)，standard edition，标准版，是我们通常用的一个版本，从JDK 5.0开始，改名为Java SE。
EE(JavaEE)，enterprise edition，企业版，使用这种JDK开发J2EE应用程序，从JDK 5.0开始，改名为Java EE。从2018年2月26日开始，J2EE改名为Jakarta EE [1] 。
ME(J2ME)，micro edition，主要用于移动设备、嵌入式设备上的java应用程序，从JDK 5.0开始，改名为Java ME。

安装目录介绍：

bin：主要存放的是java的编译器、解析器等工具
jre：java runtime environment ——java运行时环境。在jre 子目录中，JDK使用的Java运行时环境（JRE）的实现。JRE包括Java虚拟机（JVM），类库以及支持用Java编程语言编写的程序执行的其他文件。
jre/bin：java平台所使用的的工具或者可执行程序
jre/lib：jre在运行的时候需要的一些类库、属性设置、资源文件
lib：java开发工具要是用的一些类库，包含了支持JDK工具的核心类库，tools.jar、dt.jar……
src.zip：源代码。在src.zip中，构成Java核心API的所有类的Java编程语言源文件（即java.*，javax.和一些org.包的源文件，但不包括com.sun.的源文件包）

JRE：java Runtime Enviroment

是指 Java 的运行环境，是面向 Java 程序的使用者，而不是开发者，运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。

JVM：java virtual machine

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是java的核心和基础，JVM是一种用于计算设备的规范，它是一种基于下层的操作系统和硬件平台并利用软件方法来实现的抽象的计算机。可以在上面执行java的字节码程序。java编译器只需面向JVM，生成JVM能理解的字节码文件。JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台上不加修改地运行，这就是Java的能够“一次编译，到处运行”的原因。

从这张图中我们可以看出，JVM是运行在操作系统之上的，它与硬件没有直接的交互。

在 JDK的安装目录里你可以找到 jre目录里面有两个文件夹bin 和 lib,在这里可以认为 bin 里的就是 jvm， lib 中则是 jvm 工作所需要的类库，而 jvm 和 lib 合起来就称为 jre。

常见的网页类型：

HTML&HTM：HyperText Markup Language 超文本连接标示语言 .html .htm

ASP： Active Server Page 动态服务器页面（微软开发） .asp

ASP.net： ASP的下一个版本，也是建立在通用语言上的程序架构，网页后缀如.aspx

PHP： Hypertext Preprocessor 超级文本预处理言 .php .php5 .phps

JSP： JAVA Server Pages Sun Microsystems公司倡导

部署Tomcat使用jsp链接Msql

Tomcat工作模式和端口

模式：B/S模式

端口：8080

Tomcat所有软件

Jdk工具下载：

https://www.oracle.com/technetwork/cn/java/javase/downloads/jdk8-downloads-2133151-zhs.html

Tomcat:

tomcat下载页面:

MySQL-Connector-Java：

- - - 1. http://dev.mysql.com/downloads/connector/ #官网下载网站
      4. 选择5.1.47版本，因为我们mysql是5.7版本的，选择tar包下载

Tomcat-native：

Tomcat Native 这个项目可以让 Tomcat 使用 Apache 的 apr 包来处理包括文件和网络IO操作，以提升性能。就是用tomcat-native这个软件来提高tomcat处理静态页面的性能。这个软件在tomcat的bin目录下已经提供，不用单独去下载了！使tomcat处理静态的性能略逊于apache！

所有软件的版本如下：

- - - 1. MySQL-Connector-Java： mysql-connector-java-5.1.47
      2. Tomcat： apache-tomcat-8.5.42

JDK： jdk-8u171-linux-x64

MySQL： mysql-5.7.26

安装JDK

卸载openjdk

安装之前需要查看下系统是否安装了openjdk，如果安装了openjdk，请先卸载，否则安装不了oracle官方的jdk

[root@cong11 ~]# yum remove java-* -y

上传软件包

上传所有所需的软件包

[root@cong11 ~]# ls

anaconda-ks.cfg apache-tomcat-8.5.42.tar.gz jdk-8u171-linux-x64.tar.gz mysql-connector-java-5.1.47.tar.gz

解压jdk

- - - 1. [root@cong11 ~]# tar -zxvf jdk-8u171-linux-x64.tar.gz -C /usr/local/

配置JDK环境变量

[root@cong11 ~]# vim /etc/profile #在文件最后加入一下行

JAVA_HOME=/usr/local/jdk1.8.0_171

PATH=$JAVA_HOME/bin:$PATH

CLASSPATH=$JAVA_HOME/jre/lib/ext:$JAVA_HOME/lib/tools.jar

export PATH JAVA_HOME CLASSPATH

[root@cong11 ~]# source /etc/profile #使环境变量生效

查看java环境

[root@cong11 ~]# java -version

安装tomcat

解压软件包

[root@cong11 ~]# tar -zxvf apache-tomcat-8.5.42.tar.gz -C /usr/local/

重命名目录

[root@cong11 ~]# cd /usr/local/

[root@cong11 local]# mv apache-tomcat-8.5.42/ tomcat

注意：Tomcat有两种安装方式，一种是直接解压就可以使用的二进制文件，第二种是编译安装，我们这里采用了第一种方法，下载的tomcat软件直接解压就可以执行的二进制文件，因为在官方默认下载的便是使用第一种方法安装。

查看tomcat目录

[root@cong11 tomcat]# ll

各目录文件用途

tomcat

|---bin：存放启动和关闭tomcat执行脚本；

|---conf ：存放Tomcat服务器的各种全局配置文件，其中最重要的是server.xml和web.xml；

|---lib：存放Tomcat运行需要的库文件（jar），包含Tomcat使用的jar文件。unix平台此目录下的任何文件都被加到Tomcat的classpath中；

|---logs：存放Tomcat执行时的LOG文件；

|---webapps：Tomcat的主要Web发布目录，默认情况下把Web应用文件放于此目录，即供外界访问的web资源的存放目录；

|--- webapps/ROOT：tomcat的家目录

|--- webapps/ROOT/ index.jsp：Tomcat的默认首页文件

|---work：存放jsp编译后产生的class文件或servlet文件存放

|---temp：存放Tomcat运行时所产生的临时文件

conf目录中一些关键文件说明：

server.xml文件:该文件用于配置和server相关的信息，比如tomcat启动的端口号、配置host主机、配置Context
web.xml文件：部署描述文件，web.xml 文件有两部分：Servlet 类定义和Servlet 映射定义。这个web.xml中描述了一些默认的servlet，部署每个webapp时，都会调用这个文件。

这个文件中也注册了很多MIME类型，即文档类型。这些MIME类型是客户端与服务器之间说明文档类型的，如用户请求一个html网页，那么服务器会告诉客户端浏览器响应的文档是text/html类型的，这就是一个MIME类型。客户端浏览器通过这个MIME类型就知道如何处理它了。当然是在浏览器中显示这个html文件了。但如果服务器响应的是一个exe文件，那么浏览器就不可能显示它，而是应该弹出下载窗口才对。MIME就是用来说明文档的内容是什么类型的！

tomcat-users.xml文件：配置tomcat的用户密码与权限。
context.xml：每个webapp都可以使用的配置文件，它通常由专用的配置文件context.xml来定义，其存放位置为WEB-INF/目录中；此文件为所有的webapps提供默认配置；例如context.xml里设置tomcat数据源，用来连接数据库。
catalina.policy：当使用-security选项启动tomcat时，用于为tomcat设置安全策略；
catalina.properties：Java属性的定义文件，用于设定类加载器路径，以及一些与JVM调优相关参数；
logging.properties：日志系统相关的配置；

bin目录中一些关键程序说明：

[root@cong11 tomcat]# ls bin/

#bat为windows下的脚本（批处理）

#sh为Linux下的脚本，Shell

#catalina.sh是一个最关键的脚本，其他的启动脚本如startup.sh，shutdown.sh,都是使用了不同的参数调用了该脚本，startup.sh是以start参数调用了catalina.sh脚本，shutdown.sh使用stop调用了catalina.sh脚本。

[root@cong11 ~]# /usr/local/tomcat/bin/catalina.sh --help

Using CATALINA_BASE: /usr/local/tomcat

Using CATALINA_HOME: /usr/local/tomcat

Using CATALINA_TMPDIR: /usr/local/tomcat/temp

Using JRE_HOME: /usr/local/jdk1.8.0_171

Using CLASSPATH: /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar

Usage: catalina.sh ( commands ... )

commands:

debug Start Catalina in a debugger

debug -security Debug Catalina with a security manager

jpda start Start Catalina under JPDA debugger

run Start Catalina in the current window

run -security Start in the current window with security manager

start Start Catalina in a separate window

start -security Start in a separate window with security manager

stop Stop Catalina, waiting up to 5 seconds for the process to end

stop n Stop Catalina, waiting up to n seconds for the process to end

stop -force Stop Catalina, wait up to 5 seconds and then use kill -KILL if still running

stop n -force Stop Catalina, wait up to n seconds and then use kill -KILL if still running

configtest Run a basic syntax check on server.xml - check exit code for result

version What version of tomcat are you running?

Note: Waiting for the process to end and use of the -force option require that $CATALINA_PID is defined

Tomcat启动脚本

[root@cong11 tomcat]# vim /etc/init.d/tomcat

#!/bin/bash

# Tomcat init script for Linux

# chkconfig: 2345 96 14

# discription: The Apache Tomcat Server/JSP container

JAVA_HOME=/usr/local/jdk1.8.0_171/

CATALINA_HOME=/usr/local/tomcat

start_tomcat=$CATALINA_HOME/bin/startup.sh #tomcat启动文件

stop_tomcat=$CATALINA_HOME/bin/shutdown.sh #tomcat关闭文件

start() {

echo -n "Starting tomcat: "

${start_tomcat}

echo "tomcat start ok."

}

stop() {

echo -n "Shutting down tomcat: "

${stop_tomcat}

echo "tomcat stop ok."

}

# See how we were called

case "$1" in

start)

start

;;

stop)

stop

;;

restart)

stop

sleep 5

start

;;

echo "Usage: $0 {start|stop|restart}"

esac

exit 0

- - - 1. 注释：

其中2345是默认启动级别，级别有0-6共7个级别。是指tomcat在2345级别自动启动。

96启动优先级，14停止优先级，优先级范围是0－100，数字越大，优先级越低。

JAVA_HOME=/usr/local/jdk1.8.0_171/ 指定JAVA目录

CATALINA_HOME=/usr/local/tomcat #指定tomcat路径

$CATALINA_HOME/bin/catalina.sh $* #指定tomcat运行脚本

启动脚本添加执行权限

[root@cong11 tomcat]# chmod +x /etc/init.d/tomcat

建立系统服务文件

除了chkconfig可以添加系统服务，centos7开始使用systemd来管理系统服务，我们可以在/lib/systemd/system目录下创建tomcat.service文件把tomcat添加为系统服务，我们就可以使用systemctl来管理tomcat

[root@cong11 ~]# vim /lib/systemd/system/tomcat.service

[Unit]

Description=tomcat

After=network.target

[Service]

Type=forking

Environment=JAVA_HOME=/usr/local/jdk1.8.0_171/

Environment=CATALINA_HOME=/usr/local/tomcat

ExecStart=/etc/init.d/tomcat start

ExecStop=/etc/init.d/tomcat stop

ExecRestart=/etc/init.d/tomcat restart

PrivateTmp=true

[Install]

WantedBy=multi-user.target

[root@cong11 ~]# systemctl daemon-reload #重载service文件

注意只要修改了.service文件都需要执行这条命令，重载service文件

启动tomcat

[root@cong11 ~]# systemctl start tomcat

添加开机自启动

[root@cong11 ~]# systemctl enable tomcat

查看是否启动

[root@cong11 ~]# ps -ef | grep tomcat

查看端口

[root@cong11 ~]# netstat -antup | grep java

三个端口：8080为提供web服务的端口，侦听来自客户端的请求。8005为管理端口，这个端口负责监听关闭Tomcat的请求，shutdown会向该端口发送的关闭服务器的命令字符串。8009端口为第三方服务调用的端口，负责和其他HTTP服务器建立连接。在把Tomcat与其他HTTP服务器集成时就需要用到这个。

测试tomcat

浏览器访问

http://192.168.1.11:8080/

点击manager App

拒绝访问，因为这个页面需要我们配置一个账号密码，来访问。

注：如果你需要查看 Tomcat 的运行状态可以配置tomcat管理员账户，然后登陆 Tomcat 后台进行查看。

创建管理Manger App用户

修改tomcat-users.xml配置文件

[root@cong11 ~]# vim /usr/local/tomcat/conf/tomcat-users.xml

在44行上tomcat-users模块中添加标红内容

37 <!--

38 <role rolename="tomcat"/>

39 <role rolename="role1"/>

40 <user username="tomcat" password="<must-be-changed>" roles="tomcat"/>

41 <user username="both" password="<must-be-changed>" roles="tomcat,role1"/>

42 <user username="role1" password="<must-be-changed>" roles="role1"/>

43 -->

51 </tomcat-users>

- - - 1. 角色说明：

1：“manager-gui”：Allows access to the html interface（允许通过web的方式登录查看服务器信息）。

2：“manager-script”: Allows access to the plain text interface（允许以纯文本的方式访问）。

3：“manager-jmx”: Allows access to the JMX proxy interface（允许jmx的代理访问）。

4：“manager-status”: Allows access to the read-only status pages（允许以只读状态访问）。

5: admin-gui: 允许访问HTML GUI

6 : admin-script: 允许访问文本接口

tomcat8以上还要增加以下配置

[root@cong11 ~]# vim /usr/local/tomcat/conf/Catalina/localhost/manager.xml

<Context privileged="true" antiResourceLocking="false"

docBase="${catalina.home}/webapps/manager">

</Context>

[root@cong11 ~]# vim /usr/local/tomcat/webapps/host-manager/META-INF/context.xml

<Valve className="org.apache.catalina.valves.RemoteAddrValve"

allow="^.*$" /> #修改标红部分

重启tomcat

[root@cong11 ~]# systemctl restart tomcat

测试访问

查看当前配置的jvm大小：

查看jvm大小配置可以到控制台“Server Status”那个页面去，由于tomcat默认没有用户的所以无法登录控制台，所以我们需要先配置用户以使能登录控制台（参考上面的配置）。

Free memory--当前分配给jvm的内存中还剩余的内存；

Total memory--当前分配给jvm的内存大小；

Max memory--最大可分配给jvm的内存大小。

修改jvm的内存大小：

编缉$CATALINA_HOME/bin/catalina.sh，在最前面（注释除外）添加：

JAVA_OPTS='-Xms512m -Xmx1024m'

-Xms：表示java虚拟机堆内存初始内存分配的大小，虚拟机在启动时向系统申请的内存的大小，-Xmx表示最大可分配给jvm的内存大小，根据自己需要修改。一般建议堆的最大值设置为可用内存的最大值的80%。

重启tomcat使配置生效，然后再登录“Server Status”，再次查看jvm配置是否生效

执行ps查看JVM参数设置

Tomcat 6/7/8 的配置参数有点不一样，最好按下面的方式看一下官网文档

启动tomcat，访问该地址，下面要讲解的一些配置信息，在该文档下都有说明的：

文档：http://192.168.1.11:8080/docs/config

你也可以直接看网络版本：

Tomcat 6 文档：https://tomcat.apache.org/tomcat-6.0-doc/config

Tomcat 7 文档：https://tomcat.apache.org/tomcat-7.0-doc/config/

Tomcat 8 文档：https://tomcat.apache.org/tomcat-8.0-doc/config/

Tomcat架构与术语

Tomcat结构图：

Tomcat主要组件：服务器Server，服务Service，连接器Connector、容器Container。连接器Connector和容器Container是Tomcat的核心。

Tomcat中最顶层的容器是Server，代表着整个服务器，从上图中可以看出，一个Server可以包含至少一个Service，用于具体提供服务。

Service主要包含两个部分：Connector和Container。从上图中可以看出 Tomcat 的心脏就是这两个组件，它们的作用如下：

Connector用于处理连接相关的事情，并提供Socket与Request和Response相关的转化；

Container用于封装和管理Servlet，以及具体处理Request请求。

多个 Connector 和一个 Container 就形成了一个 Service，有了 Service 就可以对外提供服务了。但 Service 还要一个生存的环境，必须要有人能够给它生命、掌握其生死大权，而这就非 Server 莫属。所以，整个 Tomcat 的生命周期由 Server 控制。

Tomcat 还有其它重要的组件，如安全组件 security、logger 日志组件、session、mbeans、naming 等其它组件。这些组件共同为 Connector 和 Container 提供必要的服务。

两大组件：Connector和Container

1、Connector

一个Connecter将在某个指定的端口上侦听客户请求，接收浏览器的发过来的 tcp 连接请求，创建一个 Request 和 Response 对象分别用于和请求端交换数据，然后会产生一个线程来处理这个请求并把产生的 Request 和 Response 对象传给处理Engine(Container中的一部分)，从Engine出获得响应并返回客户。

一个服务可以有多个连接，如同时提供Http和Https链接，也可以提供向相同协议不同端口的连接，示意图如下（Engine、Host、Context下边会说到）：

Connector 最重要的功能就是接收连接请求然后分配线程让 Container 来处理这个请求，所以这必然是多线程的，多线程的处理是 Connector 设计的核心。

Tomcat中有两个经典的Connector，一个直接侦听来自Browser的HTTP请求，另外一个来自其他的WebServer请求。HTTP/1.1 Connector在端口8080处侦听来自客户Browser的HTTP请求，AJP/1.3 Connector在端口8009处侦听其他Web Server（其他的HTTP服务器）的Servlet/JSP请求。

Web客户访问Tomcat服务器上JSP组件的两种方式如图所示。

http协议访问端（默认为8080），负责建立HTTP连接。在通过浏览器访问Tomcat服务器的Web应用时，使用的就是这个连接器。

AJP协议访问端口（默认为8009端口），负责和其他的HTTP服务器建立连接。在把Tomcat与其他HTTP服务器集成时，就需要用到这个连接器。

2、Container

Container用于封装和管理Servlet，以及具体处理Request请求，在Container内部包含了4个子容器，结构图如下：

4个子容器的作用分别是：

（1）Engine：引擎，用来管理多个站点，一个Service最多只能有一个Engine；Engine用来接收并处理从Connector发来的请求，并将处理结果返回Connector。一个Engine可以包含一个或多个Host。

Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名，当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理。Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理。

（2）Host：代表一个Virtual Host，虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配，每个虚拟主机下都可以部署一个或者多个Web App，每个Web App对应于一个Context，有一个Context path。当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理。匹配的方法是“最长匹配”，所以一个path=""的Context将成为该Host的默认Context，所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配

（3）Context：一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成。Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类，当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类，如果找到，则执行该类，获得请求的回应，并返回

（4）Wrapper：每一Wrapper封装着一个Servlet。

Wrapper 代表一个 Servlet，它负责管理一个 Servlet，包括的 Servlet 的装载、初始化、执行以及资源回收。Wrapper 是最底层的容器，它没有子容器了。

Context和Host的区别是Context表示一个应用，我们的Tomcat中默认的配置下webapps下的每一个文件夹目录都是一个Context，其中ROOT目录中存放着主应用，其他目录存放着子应用，而整个webapps就是一个Host站点。

我们访问应用Context的时候，如果是ROOT下的则直接使用域名就可以访问，例如：www.abc.com，如果是Host（webapps）下的其他应用，则可以使用www.abc.com/docs进行访问。当然默认指定的根应用（ROOT）是可以进行设定的，只不过Host站点下默认的主营用是ROOT目录下的。

上述的包含关系或者说是父子关系，都可以在Tomcat的conf目录下的server.xml配置文件中看出，下图是删除了注释内容之后的一个完整的server.xml配置文件（Tomcat版本为8.5.42）

HTTP请求过程

Tomcat Server处理一个HTTP请求的过程

1、用户点击网页内容，请求被发送到本机端口8080，被在那里监听的Coyote HTTP/1.1 Connector获得。

2、Connector把该请求交给它所在的Service的Engine来处理，并等待Engine的回应。

3、Engine获得请求localhost/test/index.jsp，匹配所有的虚拟主机Host。

4、Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机），名为localhost的Host获得请求/test/index.jsp，匹配它所拥有的所有的Context。Host匹配到路径为/test的Context（如果匹配不到就把该请求交给路径名为path=””的Context去处理）。

5、path=“/test”的Context获得请求/index.jsp，在它的mapping table中寻找出对应的Servlet。Context匹配到URL PATTERN为*.jsp的Servlet,对应于JspServlet类。

6、构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet（）或doPost（）.执行业务逻辑、数据存储等程序。

7、Context把执行完之后的HttpServletResponse对象返回给Host。

8、Host把HttpServletResponse对象返回给Engine。

9、Engine把HttpServletResponse对象返回Connector。

10、Connector把HttpServletResponse对象返回给客户Browser。

搭建基于域名的虚拟主机

[root@cong11 ~]# ls /usr/local/tomcat/conf/

server.xml是Tomcat的主配置文件（全局）,服务器设置的，例如端口设置，路径设置。

修改server.xml配置文件

[root@cong11 ~]# vim /usr/local/tomcat/conf/server.xml

在末尾</Engine>上面添加标红内容

</Host>

</Host>

</Engine>

</Service>

</Server>

name指定虚拟主机的名称，那么使用对应的ip将无法访问，如果需要使用 ip 来访问，需要把 host 的name属性改成ip即可。

- - - 1. appBase指定应用程序(网站)的根目录,这里可以存放多个程序(网站),一般是相对路径,相对于tomcat的安装目录。
      2. Context path=""为虚拟目录，如果是空，表示直接就是/，如果是如path="aa",那么访问的时候就是site:8080/aa
      3. docBase="……" 为实际目录，可以是绝对路径，如果是相对路径就是基于appBase
      4. <Host> 元素的其他属性如下：
      6. 其余属性的含义可以参考
      7. https://tomcat.apache.org/tomcat-8.5-doc/config/host.htm

创建测试网页

[root@cong11 ~]# mkdir -p /www/html/{web1,web2}

[root@cong11 ~]# echo "qingniao.com web1" > /www/html/web1/index.html

[root@cong11 ~]# echo "qingniao.cn web2" > /www/html/web2/index.html

修改hosts

[root@cong11 ~]# vim /etc/hosts

192.168.1.11 www.qingniao.com

192.168.1.11 www.qingniao.cn

windows客户端修改hosts

C:\Windows\System32\drivers\etc

192.168.1.11 www.qingniao.com

192.168.1.11 www.qingniao.cn

重启tomcat

[root@cong11 ~]# systemctl restart tomcat

网页测试

http://www.qingniao.com:8080/

http://www.qingniao.cn:8080/

安装tomcat-Native

Tomcat 可以使用 apr 来提供更好的伸缩性、性能和集成到本地服务器技术。用来提高 tomcat 的性能。 tomcat native 在具体的运行平台上，提供了一种优化技术，它本身是基于 ARP（Apache Portable（轻便） Runtime）技术，我们应用了 tomcat native 技术之后，tomcat 在跟操作系统级别的交互方面可以做得更好，并且它更像apache 一样，可以更好地作为一台 web server。 tomcat 可以利用 apache 的 apr 接口，使用操作系统的部分本地操作，从而提升性能APR 提升的是静态页面处理能力.

tomcat-native下载地址

http://tomcat.apache.org/download-native.cgi

Tomcat8.5 在bin下已有tomcat-native.tar.gz，我们不需要去下载

安装依赖

[root@cong11 ~]# yum install -y apr apr-devel gcc gcc-c++ openssl-devel openssl

解压

[root@cong11 ~]# cd /usr/local/tomcat/bin/

[root@cong11 bin]# ls

[root@cong11 bin]# tar zxf tomcat-native.tar.gz -C /usr/local/src/

预编译

[root@cong11 bin]# cd /usr/local/src/tomcat-native-1.2.21-src/native/

[root@cong11 native]# ./configure --with-apr=/usr/bin/apr-1-config --with-java-home=/usr/local/jdk1.8.0_171/ --with-ssl

编译安装

[root@cong11 native]# make && make install

添加库文件：

[root@cong11 native]# vim /etc/ld.so.conf

/usr/local/apr/lib #在文档最后添加这一行

使配置文件生效

[root@cong11 native]# ldconfig

[root@cong11 native]# echo "ldconfig" >>/etc/rc.local #添加开机生效

[root@cong11 native]# chmod +x /etc/rc.d/rc.local

其实添加完ldconfig并无法立即引用类库变量，我们可以做软连接解决：

[root@cong11 native]# ln -s /usr/local/apr/lib/* /usr/lib/

重启tomcat

[root@cong11 native]# systemctl restart tomcat

看日志是否支持native

[root@cong11 native]# cat /usr/local/tomcat/logs/catalina.out | grep Native

安装mysql

安装msyql

开启cong12的mysql快照，可以自己手动安装mysql

创建测试数据

[root@cong12 ~]# mysql -uroot -p123456

mysql> create database tomcat; #创建tomcat数据库

mysql> use tomcat;

mysql> create table tt(id int,name varchar(128)); #创建tt测试表

mysql> insert into tt values (1,"come on boy"),(2,"come on girl"); #插入数据

mysql> grant all on tomcat.* to tomcat@'192.168.1.%' identified by 'tomcat'; #授权

mysql> flush privileges; #刷新权限

测试jsp链接mysql（cong11）

- - - 1. Jsp链接mysql，官方提供了工具： mysql-connector

安装mysql-connector（cong11）

解压缩软件包

因为之前已经上传过软件包，这里直接解压软件包

[root@cong11 ~]# tar -zxvf mysql-connector-java-5.1.47.tar.gz -C /usr/local/src/

[root@cong11 ~]# cd /usr/local/src/mysql-connector-java-5.1.47/

复制jar文件到tomcat的lib目录下

[root@cong11 mysql-connector-java-5.1.47]# cp mysql-connector-java-5.1.47-bin.jar /usr/local/tomcat/lib/

重启tomcat

[root@cong11 ~]# systemctl restart tomcat

建立测试页面

[root@cong11 ~]# vim /usr/local/tomcat/webapps/ROOT/mysql.jsp

注意修改mysql的IP地址，标红部分

<%@ page contentType="text/html;charset=utf-8"%>

<%@ page import="java.sql.*"%>

<html>

<body>

Class.forName("org.gjt.mm.mysql.Driver").newInstance();

String url ="jdbc:mysql://192.168.1.12/tomcat?user=tomcat&password=tomcat&useUnicode=true&characterEncoding=utf-8";

Connection conn= DriverManager.getConnection(url);

Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);

String sql="select * from tt";

ResultSet rs=stmt.executeQuery(sql);

while(rs.next()){%>

step:<%=rs.getString(1)%>

context:<%=rs.getString(2)%><br><br>

<%}%>

<%out.print("Congratulations!!! JSP connect MYSQL IS OK!!");%>

<%rs.close();

stmt.close();

conn.close();

</body>

</html>

#代码复制注意核对，由于编码问题，复制到vim中可能会增加多余的%号，记得删除

测试

http://192.168.1.11:8080/mysql.jsp

创建并发布WAR文件

Tomcat既可以运行采用开放式目录结构的Web应用，也可以运行WAR文件。我有一个java网站项目叫helloapp，只要把整个网站目录helloapp拷贝到/webapps目录下，即可运行开放式目录结构的helloapp应用。在Web应用的开发阶段，为了便于调试，通常采用开放式的目录结构来发布Web应用，这样可以方便地更新或替换文件。如果开发完毕，进入产品发布阶段，应该将整个Web应用打包为WAR文件，再进行发布。

在本例中，按如下步骤发布helloapp。

（1）进入helloapp应用的根目录/webapps/helloapp。

（2）把整个Web应用打包为helloapp.war文件，命令如下：

jar cvf helloapp.war ./*

在JDK的bin目录下提供了打包程序jar。如果要展开helloapp.war文件，命令为:

jar xvf helloapp.war

（3）把helloapp.war文件拷贝到/webapps目录下。

（4）删除原先的helloapp目录。

（5）启动Tomcat服务器。

Tomcat服务器启动时，会把webapps目录下的所有WAR文件自动展开为开放式的目录结构。所以服务器启动后，会发现服务器把helloapp.war展开到 /webapps/helloapp目录中。

Tomcat优化

隐层版本信息

隐藏HTTP 头部的版本信息

编辑server.xml，为Connector 添加 server 属性

[root@cong11 ~]# vim /usr/local/tomcat/conf/server.xml

添加红色部分的server属性

<Connector port="8080" protocol="HTTP/1.1"

connectionTimeout="20000"

redirectPort="8443" server="APP Srv1.0"/>

重启tomcat服务

[root@cong11 ~]# systemctl restart tomcat

[root@cong11 ~]# netstat -anplt | grep java

tcp6 0 0 :::8009 :::* LISTEN 25069/java

tcp6 0 0 :::8080 :::* LISTEN 25069/java

tcp6 0 0 127.0.0.1:8005 ::: LISTEN 25069/java

验证结果如下图所示：

隐藏404页面出现的版本号

有时候为了服务器安全很多信息是不能显露出来了，这其中就包含了tomcat服务器的版本号。
修改前如下：

针对该信息的显示是由一个jar包控制的，该jar包存放在 Tomcat 安装目录下的lib目录下，名称为 catalina.jar。

我们可以通过 jar xf 或unzip命令解压这个 jar 包会得到两个目录 META-INF 和 org ,通过修改org/apache/catalina/util/ServerInfo.properties 文件中的 serverinfo 字段来实现来更改我们tomcat的版本信息。

进入tomcat的lib目录找到catalina.jar文件

[root@cong11 ~]# cd /usr/local/tomcat/lib/

[root@cong11 lib]# ls

解压catalina.jar包

[root@cong11 lib]# unzip catalina.jar

修改ServerInfo.properties文件

进入org/apache/catalina/util 编辑配置文件ServerInfo.properties

[root@cong11 lib]# cd org/apache/catalina/util

[root@cong11 util]# vim ServerInfo.properties

server.info= APP Srv/1.0

server.number=1.0

server.built=Jun 4 2019 20:29:04 UTC

将修改后的信息压缩回jar包

[root@cong11 util]# cd /usr/local/tomcat/lib/

[root@cong11 lib]# jar uvf catalina.jar org/apache/catalina/util/ServerInfo.properties

删除解压目录

[root@cong11 lib]# rm -rf META-INF/ org/

重启tomcat

[root@cong11 lib]# systemctl restart tomcat

[root@cong11 lib]# netstat -anplt | grep java

tcp6 0 0 :::8009 :::* LISTEN 25243/java

tcp6 0 0 :::8080 :::* LISTEN 25243/java

tcp6 0 0 127.0.0.1:8005 :::* LISTEN 25243/java

测试

http://192.168.1.11:8080/abc.jsp

Tomcat 中的三种运行模式之运行模式的优化

Tomcat支持三种接收请求的处理方式：BIO、NIO、APR 。

BIO（Blocking IO，阻塞式）：

阻塞式I/O操作即使用的是传统 I/O操作，Tomcat7以下版本默认情况下是以BIO模式运行的，由于每个请求都要创建一个线程来处理，线程开销较大，不能处理高并发的场景，在三种模式中性能也最低。

NIO（Non-blocking IO，非阻塞IO）：

NIO是Java 1.4 及后续版本提供的一种新的I/O操作方式，是一个基于缓冲区、并能提供非阻塞I/O操作的Java API，利用java异步IO技术使Tomcat运行性能有所提升，可以通过少量的线程处理大量的请求。它拥有比传统I/O操作(BIO)更好的并发运行性能。tomcat 8版本及以上默认就是在NIO模式下允许。

Java NIO 可以让你非阻塞的使用IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。Tomcat8 在Linux系统中默认使用这种方式。

启动Tomcat后，在/usr/local/tomcat/logs/catalina.out日志中可以查看tomcat8运行模式时NIO。

不过，在tomcat8中有最新的nio2，速度更快，建议使用nio2。

修改配置文件

[root@cong11 ~]# vim /usr/local/tomcat/conf/server.xml #修改标红地方

改：

<Connector port="8080" protocol="HTTP/1.1"

connectionTimeout="20000"

redirectPort="8443" />

为：

<Connector port="8080" protocol="org.apache.coyote.http11.Http11Nio2Protocol"

connectionTimeout="20000"

redirectPort="8443" server="APP Srv1.0"/>

重启tomcat

[root@cong11 ~]# systemctl restart tomcat

[root@cong11 ~]# netstat -anplt | grep java

tcp6 0 0 :::8009 :::* LISTEN 25644/java

tcp6 0 0 :::8080 :::* LISTEN 25644/java

tcp6 0 0 127.0.0.1:8005 :::* LISTEN 25644/java

查看

http://192.168.1.11:8080/manager/html

或者在启动Tomcat后，在/usr/local/tomcat/logs/catalina.out日志中可以查看tomcat8运行模式时NIO2。

APR：Apache Portable Runtime

APR(Apache Portable Runtime/Apache可移植运行时)，是Apache HTTP服务器的支持库。你可以简单地理解为，Tomcat将以JNI的形式调用Apache HTTP服务器的核心动态链接库来处理文件读取或网络传输操作，从而大大地提高Tomcat对静态文件的处理性能。 Tomcat apr也是在Tomcat上运行高并发应用的首选模式。

从操作系统级别来解决异步的IO问题,大幅度的提高性能。必须要安装apr和native，直接启动就支持apr。

安装apr、apr-devel和native（参考前面的安装tomcat-Native）

在conf/server.xml中修改8080端口对应的Connector

<Connector port="8080" protocol="org.apache.coyote.http11.Http11AprProtocol"

connectionTimeout="20000"

redirectPort="8443" server="APP Srv1.0"/>

重启动tomcat之后，查看日志会有这一行信息，说明已经是APR模式启动了。

Tomcat 执行器（线程池）的优化

Tomcat 默认是没有启用线程池的，在 Tomcat 中每一个用户请求都是一个线程，所以我们可以使用线程池来提高性能。

使用线程池，用较少的线程处理较多的访问，可以提高tomcat处理请求的能力。

开启线程池

[root@cong11 ~]# vim /usr/local/tomcat/conf/server.xml

打开默认被注释的连接池配置：

56 <!--

57 <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"

58 maxThreads="150" minSpareThreads="4"/>

59 -->

修改为（去掉注释）：

<Executor name="tomcatThreadPool" namePrefix="catalina-exec-"

maxThreads="900" minSpareThreads="100" maxSpareThreads="500"

prestartminSpareThreads="true" maxQueueSize="300" />

重要参数说明：

name：共享线程池的名字。这是 Connector 为了共享线程池要引用的名字，该名字必须唯一。

namePrefix:在 JVM 上，每个运行线程都可以有一个 name 字符串。这一属性为线程池中每个线程的 name 字符串设置了一个前缀，Tomcat 将把线程号追加到这一前缀的后面。

maxThreads：最大并发数，默认设置 200，一般建议在 500 ~1000，根据硬件设施和业务来判断
minSpareThreads：最小空闲线程数，Tomcat初始化时创建的线程数，默认设置25
maxSpareThreads：最大空闲线程数，一旦空闲线程超过这个值，Tomcat就会关闭不再需要的线程。
prestartminSpareThreads在Tomcat初始化的时候就初始化minSpareThreads 的参数值，如果不等于 true，minSpareThreads的值就没啥效果了
maxQueueSize：最大的等待队列数，超过则拒绝请求

开启并使用线程池

在connector中设置executor [ɪɡˈzekjətər]属性指向上面的执行器

<Connector executor="tomcatThreadPool" port="8080" protocol="org.apache.coyote.http11.Http11AprProtocol"

connectionTimeout="20000"

redirectPort="8443" server="APP Srv1.0"/>

连接器（Connector）优化

Connector是连接器，负责接收客户的请求，以及向客户端回送响应的消息。所以 Connector 的优化是重要部分。默认情况下Tomcat支持200线程访问，超过这个数量的连接将被等待甚至超时放弃，所以我们需要提高这方面的处理能力。

打开tomcat安装目录\conf\server.xml文件，找到Connector的配置部分：

<Connector executor="tomcatThreadPool" port="8080" protocol="org.apache.coyote.http11.Http11AprProtocol"

connectionTimeout="20000"

redirectPort="8443" server="APP Srv1.0"/>

其中 port 代表服务接口；protocol代表协议类型；connectionTimeout 代表连接超时时间，单位为毫秒；redirectPort 代表安全通信（https）转发端口，一般配置成443。

可以看到除了这几个基本配置外并无特殊功能，所以我们需要对 Connector 进行扩展。

其中Connector 支持参数属性可以参考Tomcat官方网站（https://tomcat.apache.org/tomcat-8.5-doc/config/http.html）非常多，所以本文就只介绍些常用的。

<Connector executor="tomcatThreadPool" port="8080"

protocol="org.apache.coyote.http11.Http11Nio2Protocol"

connectionTimeout="20000"

redirectPort="8443" server="APP Srv1.0"

maxThreads="1000"

minSpareThreads="100"

acceptCount="1000"

maxConnections="1000"

maxHttpHeaderSize="8192"

tcpNoDelay="true"

compression="on"

disableUploadTimeout="true"

enableLookups="false"

URIEncoding="UTF-8"/>

参数说明：

maxThreads:最大线程数。即最多同时处理的连接数，Tomcat使用线程来处理接收的每个请求。这个值表示Tomcat可创建的最大的线程数。如果没有指定，该属性被设置为200。如果使用了executor将忽略此连接器的该属性，连接器将使用executor。

minSpareThreads:最小空闲线程数。

acceptCount:接受最大队列长度，当队列满时收到的任何请求将被拒绝。

maxConnections:在任何给定的时间服务器接受并处理的最大连接数。

connectionTimeout：超时等待时间（毫秒）

maxHttpHeaderSize:请求头最大值

tcpNoDelay:如果为true，服务器socket会设置TCP_NO_DELAY选项，在大多数情况下可以提高性能。缺省情况下设为true

compression：是否开启压缩GZIP 。可接受的参数的值是“off ”（禁用压缩），“on ”（允许压缩，这会导致文本数据被压缩），“force ”（强制在所有的情况下压缩）。提示：压缩会增加Tomcat负担，最好采用Nginx + Tomcat 或者 Apache + Tomcat 方式，压缩交由Nginx/Apache 去做。

disableUploadTimeout：此标志允许servlet容器在数据上传时使用不同的连接超时，通常较长。如果没有指定，该属性被设置为true，禁用上传超时。

enableLookups：关闭DNS反向查询，DNS反查很耗时间

禁用AJP连接器

在服务状态页面中可以看到，默认状态下会启用AJP服务，并且占用8009端口。

AJP连接器可以通过AJP协议和一个web容器进行交互

Web客户端访问tomcat服务器上jsp组件的2种方式：

AJP端口用来与应用服务器交互时候用，比如apache连接tomcat等，由于 Tomcat 服务器相对于 Nginx 服务器在处理静态资源上效率较低。因此我们的网站服务器一般是 Nginx+Tomcat，Nginx 负责处理静态资源，因此 AJP 协议我们在使用 Nginx+Tomcat 架构时可以禁止掉。

修改conf下的server.xml文件，将AJP服务禁用掉即可。

[root@cong11 ~]# vim /usr/local/tomcat/conf/server.xml

修改：

为：

重启tomcat

[root@cong11 ~]# systemctl restart tomcat

测试

http://192.168.1.11:8080/manager/status?org.apache.catalina.filters.CSRF_NONCE=D25C63487C4738AA38C0E52B6FE31DB4

里面的AJP不见了

或者执行netstat查看8009端口的监听。

禁用8005端口

SHUTDOWN端口是写在server参数里面的，一般在安全设置时候建议把端口修改为其他端口，SHUTDOWN修改为其他复杂的字符串。

实际上这个端口是可以直接屏蔽不监听的。设置时候将其port值修改为-1就可以。

[root@cong11 ~]# vim /usr/local/tomcat/conf/server.xml

修改：

为：

Tomcat 中 JVM 参数优化

对jvm参数的优化我们主要是对堆内存的优化。

Java 的内存模型分为：

由上图可以清楚的看到JVM的内存空间分为3大部分：

1.堆内存

2.方法区

3.栈内存

其中栈内存可以再细分为java虚拟机栈和本地方法栈。

堆内存可以划分为新生代（Young，年轻代）和老年代（Tenured [ˈtenjərd]）,新生代中还可以再次划分为Eden（[ˈiːdn]）区、From Survivor区和To Survivor（[sərˈvaɪvər]）区。

注：堆和栈是程序运行的关键，很有必要把他们的关系说清楚。

Java栈是与每一个线程关联的，JVM在创建每一个线程的时候，会分配一定的栈空间给线程。它主要用来存储线程执行过程中的局部变量，方法的返回值，以及方法调用上下文。栈空间随着线程的终止而释放。

Java中堆是由所有的线程共享的一块内存区域，堆用来保存各种JAVA对象，比如数组，线程对象等。

堆内存（Heap [hiːp]）：

对于大多数应用来说，Java 堆（Java Heap）是Java 虚拟机所管理的内存中最大的一块。Java 堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。

此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。

堆内存是所有线程共有的，可以分为两个部分：年轻代和老年代。

Young，年轻代，对象在被创建时，内存首先是在年轻代进行分配（注意，大对象可以直接在老年代分配）。当年轻代需要回收时会触发Minor GC(也称作Young GC，Garbage Collection，垃圾收集，垃圾回收)。Young 区被划分为三部分，Eden 区和两个大小相同的 Survivor 区，其中 Survivor 区间中，某一时刻只有其中一个是被使用的，另外一个留做垃圾收集时复制对象用，在 Young 区间变满的时候，minor GC （[ˈmaɪnər]）就会将存活的对象移到空闲的Survivor 区间中，根据 JVM 的策略，在经过几次垃圾收集后，任然存活于 Survivor 的对象将被移动到 Tenured 区间。
Tenured，老年代。老年代用于存放在年轻代中经多次垃圾回收仍然存活的对象，可以理解为比较老一点的对象，例如缓存对象，一般如果系统中用了 application 级别的缓存，缓存中的对象往往会被转移到这一区间。当一些对象在 Young 复制转移一定的次数以后，对象就会被转移到 Tenured 区。当老年代满了的时候就需要对老年代进行垃圾回收，老年代的垃圾回收称作Major GC（也称作Full GC）。 Major [ˈmeɪdʒər]

方法区（Method Area）：

方法区存放了要加载的类的信息(如类名，修饰符)、类中的静态变量、final定义的常量、类中的field、方法信息，当开发人员调用类对象中的getName、isInterface等方法来获取信息时，这些数据都来源于方法区。方法区是全局共享的，在一定条件下它也会被GC。当方法区使用的内存超过它允许的大小时，就会抛出OutOfMemory：PermGen Space异常。

在JDK8之前的Hotspot虚拟机中，这块区域对应的是Permanent Generation(永久代)，一般的，方法区上执行的垃圾收集是很少的，因此方法区又被称为持久代的原因之一。

随着JDK8的到来，JVM不再有永久代(PermGen)。但类的元数据信息（metadata）还在，只不过不再是存储在连续的堆空间上，而是移动到叫做“Meta space”的本地内存(Native memory）。

JVM 参数优化

对jvm参数的优化我们主要是对堆内存的优化。

下图中的Perm代表的是永久代，但是注意永久代并不属于堆内存中的一部分。

1、对于堆区大小，可以通过参数-Xms和-Xmx来控制，-Xms为JVM启动时向系统申请的heap内存，默认为物理内存的1/64，但小于1GB;-Xmx为JVM可申请的最大Heap内存，默认为物理内存的1/4但小于1GB,默认当剩余堆空间小于40%时，JVM会增大Heap到-Xmx大小，可通过-XX:MinHeapFreeRatio参数来控制这个比例；当空余堆内存大于70%时，JVM会减小Heap大小到-Xms指定大小，可通过-XX:MaxHeapFreeRatio来指定这个比例。对于系统而言，为了避免在运行期间频繁的调整Heap大小，我们通常将-Xms和-Xmx设置成一样。

2、年轻代由Eden Space和两块相同大小的Survivor Space（又称S0和S1）构成，可通过-Xmn参数来调整新生代大小，也可通过-XX:SurvivorRatio来调整Eden Space和Survivor Space大小。

默认的，Eden : from : to = 8 : 1 : 1 ( 可以通过参数 –XX:SurvivorRatio 来设定 )，即： Eden = 8/10 的新生代空间大小，from = to = 1/10 的新生代空间大小。

3、老年代所占用的内存大小为-Xmx对应的值减去-Xmn对应的值。

4、JVM方法区的相关参数，最小值：--XX:PermSize；最大值 --XX:MaxPermSize。

年轻代 ( Young ) 与老年代 ( Old ) 的比例的值为 1:2 ( 该值可以通过参数 –XX:NewRatio 来指定 )

总结：JVM按照其存储数据的内容将所需内存分配为堆区与非堆区两个部分：

所谓堆区即为通过new的方式创建的对象（类实例）所占用的内存空间, 堆是运行时数据区域；

非堆区即为代码、常量、外部访问（如文件访问所占资源）等。

配置堆区的（-Xms 、-Xmx、-XX:newSize、-XX:MaxnewSize、-Xmn）

配置非堆区（-XX:PermSize、-XX:MaxPermSize）

Linux文件修改/usr/local/tomcat/bin/catalina.sh文件，添加下面的信息。

Linux 下 catalina.sh 在一大段注释的下面，正文配置的上面加入：

[root@cong11 ~]# vim /usr/local/tomcat/bin/catalina.sh

要添加在tomcat 的bin 下catalina.sh 里，位置cygwin=false前。注意引号要带上,红色的为新添加的.

# OS specific support. $var _must_ be set to either true or false.

#在110行添加如下内容

export JAVA_OPTS="-server -Xms1024M -Xmx1024M -Xmn512M -Xss512k -XX:PermSize=256M -XX:MaxPermSize=512M -XX:NewRatio=2 -XX:SurvivorRatio=4 -XX:MaxTenuringThreshold=10 -XX:+DisableExplicitGC -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:ParallelGCThreads=20 -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:LargePageSizeInBytes=128m -XX:+UseFastAccessorMethods -XX:+UseCMSInitiatingOccupancyOnly -Djava.awt.headless=true"

主要参数说明：

-server：表示这是应用于服务器的配置。
-Xms：表示java虚拟机堆区内存初始内存分配的大小，虚拟机在启动时向系统申请的内存的大小。
-Xmx：表示java虚拟机堆区内存可被分配的最大上限，通常会将 -Xms 与 -Xmx两个参数的配置相同的值，初始堆内存与最大堆内存大小设为一致，这样虚拟机一次性的分配内存，而不至于在初始堆大小不够用又向系统分配内存。

而堆的最大值受限于系统使用的物理内存。一般使用数据量较大的应用程序会使用持久对象，内存使用有可能迅速地增长。当应用程序需要的内存超出堆的最大值时虚拟机就会提示内存溢出，应用可能会导致java.lang.OutOfMemory错误，并且导致应用服务崩溃。因此一般建议堆的最大值设置为可用内存的最大值的80%。

-Xmn：设置年轻代大小，
-XX:newSize：表示年轻代初始内存的大小，应该小于 -Xms的值；
-XX:MaxnewSize：表示年轻代可被分配的内存的最大上限；当然这个值应该小于 -Xmx的值；

-Xmn：至于这个参数则是对 -XX:newSize、-XX:MaxnewSize两个参数的同时配置，也就是说如果通过-Xmn来配置年轻代的内存大小，那么-XX:newSize = -XX:MaxnewSize = -Xmn，虽然会很方便，但需要注意的是这个参数是在JDK1.4版本以后才使用的。

-Xss：是指设定每个线程的栈大小。这个就要依据你的程序，看一个线程大约需要占用多少内存，可能会有多少线程同时运行等。
-XX:PermSize：表示非堆区初始内存分配大小，其缩写为permanent size（持久化内存）
-XX:MaxPermSize：表示对非堆区分配的内存的最大上限。XX:MaxPermSize设置过小会导致java.lang.OutOfMemoryError: PermGen space 就是内存益出。

这里面非常要注意的一点是：在配置之前一定要慎重的考虑一下自身软件所需要的非堆区内存大小，因为此处内存是不会被java垃圾回收机制进行处理的地方。并且更加要注意的是最大堆内存与最大非堆内存的和绝对不能够超出操作系统的可用内存。

-XX:NewRatio：设置年轻代（包括 Eden 和两个 Survivor 区）与老年代的比值（除去永久代）。设置为 2，则年轻代与终身代所占比值为 1：2，年轻代占整个堆栈的 1/3。
-XX:SurvivorRatio=4：设置堆内存年轻代中Eden区与Survivor区大小的比值。设置为4，则两个Survivor区（JVM堆内存年轻代中默认有2个Survivor区）与一个Eden区的比值为2:4，一个Survivor区占整个年轻代的1/6。
-XX:MaxTenuringThreshold：设置垃圾最大年龄，默认为：15。如果设置为0 的话，则年轻代对象不经过 Survivor 区，直接进入年老代。

对于年老代比较多的应用，可以提高效率。如果将此值设置为一个较大值，则年轻代对象会在 Survivor 区进行多次复制，这样可以增加对象再年轻代的存活时间。增加对象在年轻代即被回收的概率。

需要注意的是，设置了 -XX:MaxTenuringThreshold，并不代表着，对象一定在年轻代存活15次才被晋升进入老年代，它只是一个最大值，事实上，存在一个动态计算机制，计算每次晋入老年代的阈值，取阈值和MaxTenuringThreshold中较小的一个为准。

-XX:+UseParNewGC：设置年轻代为并发收集。
-XX:+UseConcMarkSweepGC：设置年老代为并发收集。
-XX:ParallelGCThreads=20:配置并行收集器的线程数,即:同时多少个线程一起进行垃圾回收。此值最好配置与处理器数目相等。

压力测试JMeter

JMeter简介

Apache JMeter是Apache组织开发的基于Java的压力测试工具。用于对软件做压力测试，它最初被设计用于Web应用测试，但后来扩展到其他测试领域。它可以用于测试静态和动态资源，例如静态文件、Java 小服务程序、CGI 脚本、Java 对象、数据库、FTP 服务器，等等。JMeter 可以用于对服务器、网络或对象模拟巨大的负载，来自不同压力类别下测试它们的强度和分析整体性能。

Apache JMeter是开源的压力测试工具，测量tomcat的吞吐量等信息。