8月10日上课内容 Tomacat部署及优化

tomcat 开放源代码的web应用服务器。基于java代码开发的。

Tomcat介绍

tomcat就是处理动态请求和基于java代码的页面开发
可以在html当中写入java代码，tomcat可以解析html页面当中的java,执行动态请求，动态页面。
缺点是机制有问题:不对tomcat进行优化，会出现在:假死、停机。小集群，小服务，小应用适用于tomcat,大并发的场景不适合。

优点

1、免费

2、开源，可以二次封装。

3、可配置型强，可以根据需要进行自定义配置，包括端口号，虚拟主机，等等。

4、安全性: tommcat自带安全机制，可以配置用户认证、授权、加密传输

5、部署应用非常快捷: tocat会自动部署，自动运行.
webapps。
python node.js  javase
 

核心组件三个:

1、web容器:完成web服务器的功能，web应用

web----->http(s)-------访问页面--------->文件index.jsp

web容器中，封装了一组文件，在这一组文件之中，进行集中化管理。

web动态页面。

2、servlet容器:名字：catalina，处理servlet代码

就是处理web请求(http)，以及生成动态内容的java类。

处理http请求。

3、jsp：jsp动态界面翻译成servlet代码，用标准格式，展示jsp的静态页面。

写好一个包，就把它上传到webapps下，重启服务即可。部署方便

servlet补充：

1、处理http请求

2、生成动态内容，为了和数据库交互------>用户发起的：jsp当中的

3、会话管理，跟踪用户在不同请求之间的状态，通过管理，可以在用户访问不同页面时保持用户的状态。

session

4、与数据库交互，servlet可以连接到数据库，执行查询和更新操作。这就是servlet能够生成动态内容的原因。

jsp:java server pages。动态页面的开发技术。使用jsp标签 index.jsp 在html页面中插入java代码。

jsp容器------->html页面当中的java代码翻译------>执行-------------->展示结果。

通常以<%,开头

           %>,结尾

java基本知识普及：

面向对象:编程范式。思想。客观存在的实体和他们之间的关系，映射到计算机程序当中。
计算机程序被组织成这一组相互作用的对象，每个对象都有数据(属性)和行为(方法)。

类:定义一组属性和方法
创建对象。实例。

封装:对象的属性和方法捆绑在一块，提供一个接口，可以让其他对象使用。
继承:一个类，可以继承另一个类 类 子类 子类可以重用父类的代码，而且还在不修改代码的情况下，进行扩展。
多态: 不同类的对象对相同的消息，做出不同的响应。

详解：

面向对象（Object-Oriented）是一种编程范式或思想，它在软件设计和开发中广泛应用。
面向对象编程（OOP）是一种将现实世界的实体（对象）和它们之间的关系映射到计算机程序中的方法。
在面向对象编程中，计算机程序被组织为一组相互作用的对象，每个对象都有数据（属性）和行为（方法）。

关键概念和特性包括：

类和对象（Objects and Classes）：类是一个抽象的模板或蓝图，定义了一组属性和方法，
而对象是基于类创建的实例。类描述了对象应该有的属性和行为。

封装（Encapsulation）：封装指的是将数据和方法（行为）捆绑在一起，隐藏了对象的内部细节，
只公开必要的接口供其他对象使用。这有助于实现信息隐藏和数据保护。

继承（Inheritance）：继承是一种机制，允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）
的属性和方法。子类可以重用父类的代码，并可以在不修改原始代码的情况下进行扩展或修改。

多态（Polymorphism）：多态性允许不同类的对象对相同的消息作出不同的响应。
这使得在面向对象编程中可以创建通用的代码，能够处理多种类型的对象。

功能组件（结构）：

connector:负载对外接受和响应请求，是tomcat与外界的交通枢纽，监听端口，也可以接受外界请求，交给container处理。

container:负责对内处理业务逻辑。

container里面有：
Engine:引擎，管理虚拟机 (service,一个service里面可以包含多个虚拟主机。)可以管理多个虚拟主机，一个service里面只能有一个Engine;
Host: 代表一个虚拟机，也可以叫站点
Context: web应用。包含多个servlet。
wrapper:封装器，最底层，每一个wrapper封装一个servlet,负责对象实例的创建，执行，销毁。

父子关系，工作方式也是从上到下。

Tomcat处理请求的过程（重点，理解，记忆1）

Tomcat处理请求的具体过程：

1、输入网址，请求发送，请求发送到8080端口，被监听的获得;
2、connector会把请求转发到container处理---->engine (虚拟主机，你要访问哪一个虚拟主机)

----->host(主机站点包含要请求页面的位置。webapps)------>从contex，就是indexjsp里面的内容。------->wrapper(servlet，响应解析处理请求)-------jsp翻译官

--------------->页面展示。

Tomcat 请求过程解析：
1、用户在浏览器中输入网址，请求被发送到本机端口 8080，被在那里监听的 Connector 获得；

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

3、请求在 Engine、Host、Context 和 Wrapper 这四个容器之间层层调用，
最后在 Servlet 中执行对应的业务逻辑、数据存储等。

4、执行完之后的请求响应在 Context、Host、Engine 容器之间层层返回，最后返回给 Connector，
并通过 Connector 返回给客户端。

扩展 详细请求过程示例：
假设来自客户的请求为： http://localhost:8080/ky30/ky30_index.jsp 
1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得 

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

3) Engine获得请求localhost/ky30/ky30_index.jsp，匹配它所拥有的所有虚拟主机Host 

4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
 
5) localhost Host获得请求/ky30/ky30_index.jsp，匹配它所拥有的所有Context 

6) Host匹配到路径为/ky30的Context（如果匹配不到就把该请求交给路径名为""的Context去处理） 

7) path="/ky30"的Context获得请求/ky30_index.jsp，在它的mapping table中寻找对应的servlet 

8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类 

9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法 

10)Context把执行完了之后的HttpServletResponse对象返回给Host 

11)Host把HttpServletResponse对象返回给Engine 

12)Engine把HttpServletResponse对象返回给Connector 

13)Connector把HttpServletResponse对象返回给客户browser
 

Tomcat服务部署

在部署 Tomcat 之前必须安装好 jdk，因为 jdk 是 Tomcat 运行的必要环境。

1.关闭防火墙，将安装 Tomcat 所需软件包传到/opt目录下

jdk-8u201-linux-x64.rpm
apache-tomcat-9.0.16.tar.gz

systemctl stop firewalld
systemctl disable firewalld
setenforce 0

2.安装JDK

cd /opt
rpm -ivh jdk-8u201-linux-x64.rpm 
java -version

3.设置JDK环境变量

vim /etc/profile.d/java.sh

export JAVA_HOME=/usr/java/jdk1.8.0_201-amd64

指定jdk的安装路径。jdk解释器，类似于shell，各种工具。
export CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar

classpath：定义类的环境变量，环境类的库。
export PATH=$JAVA_HOME/bin:$PATH

可执行文件。

source /etc/profile.d/java.sh
java -version 查看安装版本

 

使用文本工具编写java源代码，比如 Hello.java ；
在命令行中，输入命令：javac Hello.java，对源代码进行编译，生成 class 字节码文件；
编译完成后，如果没有报错信息，输入命令：java Hello，运行 class 字节码文件，由 JVM 对字节码进行解释和运行，
打印 “Hello World”。

vim Hello.java

public class Hello {            
  public static void main(String[] args){
    System.out.println("Hello world!");
  }
}

javac Hello.java
java Hello

4.安装启动Tomcat

cd /opt
tar zxvf apache-tomcat-9.0.16.tar.gz
mv apache-tomcat-9.0.16 /usr/local/tomcat
##启动tomcat ##
#后台启动
/usr/local/tomcat/bin/startup.sh 
或
/usr/local/tomcat/bin/catalina.sh start
    
#前台启动
/usr/local/tomcat/bin/catalina.sh run        

netstat -natp | grep 8080

浏览器访问Tomcat的默认主页 http://192.168.233.21:8080
 

主要目录详解：

bin: 存放的启动和关闭tomcat脚本文件
conf：主配置文件 serverxml 主配置文件 ontex htmhost的默认配置信息 tomat-userxml : 认证用户密码的置文件 web.xm:配置servlet servlet的规范标准。
lib: tomcat运行库的jar包，一般不动，除非连接第三方-----redis，数据库

logs:日志文件
webapps: web应用部署的默认目录。
work:tomcat的工作目录。存放jsp编译之后的class文件，清楚tomcat缓存，就是删work目录。

 查看端口有没有起来，再到浏览器中访问

表示启动成功

5.优化tomcat启动速度（记忆）

第一次启动tomcat可能会发现 Tomcat 启动很慢，默认情况下可能会需要几十秒，可以修改jdk参数进行改。
vim /usr/java/jdk1.8.0_201-amd64/jre/lib/security/java.security
--117行--修改
securerandom.source=file:/dev/urandom
----------------------------------------------------------------------------------------------------------
/dev/urandom是/dev/random的非阻塞版本，/dev/random的 random pool 依赖于系统中断，因此在系统的中断数不足时，
/dev/random 设备会一直封锁，尝试读取的进程就会进入等待状态，直到系统的中断数充分够用，
/dev/random设备可以保证数据的随机性。 /dev/urandom不依赖系统的中断，也就不会造成进程忙等待，
但是数据的随机性也不高，所以该随机数的安全性理论上不高。如果应用对安全性要求很高，那么应该使用/dev/random。

查看manager文件：
cd /usr/local/tomcat/webapps/manager/META-INF
vim context.xml

<Context antiResourceLocking="false" privileged="true" >
  <Valve className="org.apache.catalina.valves.RemoteAddrValve"
         allow=".*" /> #允许所有主机访问。

在conf,tomcat-users.xml中，添加账户密码
<role rolename="manager-gui"/>
<user username="tomcat" password="tomcat" roles="manager-gui"/>

 

重启一下

再访问，就会提示要输入账号 密码

 

JVM（核心，面试会问）

JVM:就是java的虚拟机，是ava应用程序在计算上运行的核心组件，jm负将编译后的java字节码(class文件)解释或者编译成本地的机器码，计算机能够执行它。JVM还提供好了内存管理，垃圾回收，线程管理。确保java程序在不同平台可以有一致性的功能。
 

JVM优化（重点，代码记忆）:

catalina.sh 就是servlet代码。以及容器的配置

 vim catalina.sh

 改完配置文件，重启一下

 再回来看一下JVM，内存发生了变化（优化了内存池）

内存池名词释义（重点）

catalina.sh 就是servlet代码。以及容器的配置

PS Eden Space: 堆内存: 存储新创建的对象
PS Old Gen:堆内存，存储长时间存活的对象
Ps Survivor Space: 堆内存: 存在创建之后，生命周期较短的对象。
Code Cache:非堆内存: 存储已经编译的代码
Compressed Class Space: 非堆内存: 存储已经压缩的类
Metaspace: 非堆内存，存储类的元数据。

优化命令（重要代码，面试会问，死记也得记住）

Tomcat配置JVM参数：

JAVA_OPTS="$JAVA_OPTS -server -Xms2048m -Xmx2048m -Xmn768m -XX:ParallelGCThreads=2 -XX:PermSize=1024m -XX:MaxPermSize=1024m -Djava.awt.headless=true -XX:+DisableExplicitGC" 

cygwin=false上面写

-server：第一个参数，指定内存池，一定放在第一个。
-Xms2048m：初始java堆的大小。分配JVM的最小内存，看cpu:cpu性能高，这个值，可以设高一点
-Xmx2048m：JAVA堆最大能多大，jvm的最大内存。和硬件内存挂钩。根据官方文档，起始值和最大值保持一致。XMS和XMX设为一样的，内存可以设为物理内存的一般。
-Xmn768m ：新生代的内存大小。官方推荐为了整个堆大小的3/8.
-XX:ParallelGCThreads=2： 配置并行收集器的线程数，同时可以有多少个线程进行垃圾回收。
-XX:PermSize：设置持久代内存的大小，默认是物理内存的1/4。
-XX:MaxPermSize=1024m ：最大的非堆内存的大小，默认也是物理内存的1/4；
-XX:PermSize=1024m -XX:MaxPermSize=1024m
非堆内存是不会被垃圾回收机制处理的，-XX:PermSize持久代内存与最大非堆内存不能超出操作系统可用的内存。设置成一样大，可以减轻伸缩堆大小的压力。
-Djava.awt.headless=true：避免在linux环境下，web不能正常打开以正常显示图片。
-XX:+DisableExplicitGC" ：避免jvm空间大起大落，影响系统的响应时间。响应速度会很慢。

堆区当中：新生代 中生代 老年代（释义也得记）

堆区当中:新生代 中生代 老年代
每一个新建的对象占用的空间，就是新生代。
java垃圾回收机制对堆区进行资源回收，新生代中没有被回收的资源，就是中生代。
中生代没有被回收，就是老年代。
jvm大小: 新生代+中生代+老年代+永久代。

详解：

新生代（Young Generation）：新生代是Java堆内存的一部分，用于存放刚刚被创建的对象。在Java程序中，
有很多对象是很快被创建和销毁的，这些短时间存活的对象会被分配到新生代中。
新生代又可以细分为三个部分：Eden区（Eden Space）和两个Survivor区（Survivor Space，通常是S0和S1）。
新对象首先被分配到Eden区，当Eden区满了之后，会触发Minor GC（年轻代垃圾回收），
将存活的对象复制到其中一个Survivor区，同时清理不再使用的对象。经过多次Minor GC后，
仍然存活的对象会被移到老年代。

老年代（Old Generation）：老年代是Java堆内存的另一部分，用于存放长时间存活的对象。在Java程序中，
有一些对象会被频繁使用，并且存活时间很长，这些长时间存活的对象会被移到老年代中。
老年代的内存空间通常比较大，因为其中存放的对象有较长的生命周期。当老年代的内存空间不足时，
会触发Major GC（老年代垃圾回收），对老年代进行整理和清理，以释放不再使用的对象。

合理设置新生代和老年代的大小以及选择合适的垃圾回收器，可以提高Java应用程序的性能和垃圾回收效率。

ajp-nio-8009

"ajp-nio-8009"优化：（面试也会问）

ajp-nio: 这是连接器的类型。"ajp" 表示使用 AJP 协议，而 "nio" 表示使用 NIO 技术进行异步非阻塞通信。
8009:连接器正在监听的端口。connect.
AJP: 将tomcat服务器与前端web服务器进行连接。提供负载均衡和高效的请求转发

详细释义：

8009: 这是连接器监听的端口号。在这种情况下，"8009" 表示连接器正在监听的端口号。

AJP 协议通常用于将Tomcat服务器与前端的Web服务器（如Apache HTTP Server）进行连接，
以提供负载均衡和高效的请求转发。NIO 技术允许非阻塞的I/O操作，提高了服务器的并发处理能力。

"ajp-nio-8009" 表示Tomcat服务器已经设置了一个监听在8009端口上的AJP连接器，
用于与其他服务器或代理进行通信。这通常是用来优化网站的性能和可靠性，以及实现负载均衡和反向代理等功能。

http-nio-8080

处理http请求。和客户端通信的接口。

Tomcat 虚拟主机配置

一台服务器上运行多个 Tomcat 服务，这样会消耗太多的系统资源。此时， 就需要使用到 Tomcat 虚拟主机。减少系统的资源消耗。
例如现在新增两个域名 www.kgc.com 和 www.benet.com， 希望通过这两个域名访问到不同的项目内容。

配置方法：

1.创建 kgc 和 benet 项目目录和文件

先看服务起没起来 netstat -antp | grep 8080

mkdir /usr/local/tomcat/webapps/kgc   
mkdir /usr/local/tomcat/webapps/benet

在两个目录里面写一些东西
echo "This is kgc page\!" > /usr/local/tomcat/webapps/kgc/index.jsp
echo "This is benet page\!" > /usr/local/tomcat/webapps/benet/index.jsp

 

 

 

2.修改 Tomcat 主配置文件 server.xml（配置host主机）

修改前记得备份一下

vim /usr/local/tomcat/conf/server.xml

先把前面默认自带的<Host > 删除
--165行前--插入
<Host name="www.kgc.com" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
    <Context docBase="/usr/local/tomcat/webapps/kgc" path="" reloadable="true" />
</Host>   

<Host name="www.benet.com" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
    <Context docBase="/usr/local/tomcat/webapps/benet" path="" reloadable="true" />
</Host>

注：以什么为开头，就要以什么为结尾

 修改后：

 一样重启一下

名词释义：

<Host name="www.kgc.com”appBase="webapps”unpackWARs="true” autoDeploy="true"Xm7vaTidation="false"” xmINamespaceAware="false">
<Context docBase="/usr/ocal/tomcat/webapps/kgc”path="” reloadable="true”/></Host>

hostname:主机名
appBase:存放web程序的目录
unpackWARs:优先对war文件进行展开，默认就是true.
autoDeploy:只要tomcat处于运行，会对webapps中的文件进行自动部署。默认也是true
xmivalidation:是否验证xml文件的有效性。默认就是false

xmlNamespaceAware: 是否验证命名空间。
<Context docBase="/usr/local/tomcat/webapps/kgc”

www.kgc.com 就是访问/usr/local/tomcat/webapps/kgc/index.jsp

详解：
Host name：主机名
appBase：Tomcat程序工作目录，即存放web应用程序的目录；相对路径为webapps，绝对路径为 /usr/local/tomcat/webapps
unpackWARs：在启用此webapps时是否对WAR格式的归档文件先进行展开；默认为true
autoDeploy：在Tomcat处于运行状态时放置于appBase目录中的应用程序文件是否自动进行deploy；默认为true
xmlValidation：是否验证xml文件执行有效性检验的标志
xmlNamespaceAware：是否启用xml命名空间，设置该值与xmlValidation为true，表示对web.xml文件执行有效性检验

docBase：相应的Web应用程序的存放位置；也可以使用相对路径，起始路径为此Context所属Host中appBase定义的路径；
path：相对于Web服务器根路径而言的URI；如果为空“”，则表示为此webapp的根路径 / ；
reloadable：是否允许重新加载此context相关的Web应用程序的类；默认为false
 

/usr/local/tomcat/bin/shutdown.sh
/usr/local/tomcat/bin/startup.sh

3.客户端浏览器访问验证
echo "192.168.233.71 www.kgc.com www.benet.com" >> /etc/hosts 做host映射

浏览器访问要加上端口号 http://www.kgc.com:8080/   页面显示This is kgc page\! 
浏览器访问                       http://www.benet.com:8080/   页面显示This is benet page\!

访问结果：

HTTP 请求过程：
（1）Connector 连接器监听的端口是 8080。由于请求的端口和监听的端口一致，连接器接受了该请求。
（2）因为引擎的默认虚拟主机是 www.kgc.com，并且虚拟主机的目录是webapps。
所以请求找到了 tomcat/webapps 目录。
（3）访问的路径为根路径，URI 为空，即空是 Web 程序的应用名，也就是 context。
此时请求找到 /usr/local/tomcat/webapps/kgc 目录，解析 index.jsp 并返回。

Tomcat自身的一些优化：

启动速度优化

第一次启动tomcat会发现启动速度很慢，10几秒-1分钟

jdk的参数:

vim   /usr/java/jdk1.8.0_201amd64/jre/lib/security/java.security

securerandom.source=file:/dev/urandom 把非阻塞打开

 

Tomcat优化：

server.xml针对主配置文件的优化。

redirectPort: 如果某连接器支持的协议的是http,当接受客户端发来的请求时https,就会启用此端口。8443。

maxthreads: tomcat使用线程来处理请求的，可以创建的最大线程数，也就是并发连接数。默认200

minsparethreads;最小空闲线程数，开启tomcat时，会有多少线程

 配置：

 

重启一下

登陆进去看一下Server Status

这里面就可以看到具体的min/max

比较重要的，还有很多其他的，不一一列举

redirectPort: 如果某连接器支持的协议的是http,当接受客户端发来的请求时https,就会启用此端口。8443.

maxthreads: tomcat使用线程来处理请求的，可以创建的最大线程数，也就是并发连接数。默认200

minsparethreads:最小空闲线程数，开启tomcat时，会有多少线程。默认是10.

maxSparethreads;最大备用线程。一旦创建的线程超过这个值，tomca会关闭不再需要的端口线程，默认是-1，也就是不限制。一般不指定
URIEncoding:URL的格式编码，默认utf-8。需要分别指定，所以一般也不动
connnectionTimeout: 网络连接超时，单位: 毫秒。为0，永不超时，一般为20000毫秒enablelookups:是否反向解析域名，为了能够获取远程的主机名。一般设置为false，直接返回IP地址，提高了处理能力
disableUploadTimeout: 上传超时时间，设置为true.
connkectionUploadTimeout: 因人而异，没有标准答案，1分钟，30秒。
acceptCount: 所有可以使用的线程都被占用了，可以传入连接请求的最大队列长度。默认100个。101个，超出范围，直接丢弃，不再处理。

compression：是否开启页面和响应数据的压缩。off 关 on 开 force（所有的情况下都进行压缩。）默认是off 建议on

compressionMinSize 压缩响应的最小值，等于或者小于这个值，就不再压缩了。2048

compressableMimeType: 可以被压缩MIME的类型

浏览器和其他互联网应用程序之间处理文件的协议和需要处理的文档的性质和格式

文本: text/html,text/plain
图像: image/jpg image/gif
音频:audio/wav audio/mp3
视频: video/mp4 video/avi
应用程序: application/pdf application/json.

vim /usr/local/tomcat/conf/server.xml

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

connectionTimeout="20000”redirectPort="8443” />
--71行--插入minSpareThreads="50

enableLookups="false"
disableUploadTimeout="true
acceptCount="300"
maxThreads="500"
processorCache="500
URIEncoding="UTF-8
compression="on"
compressionMinSize="2048"
compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain,image/gif,image /jpg,image/png"/> 

​​​​​​​

内核优化 

Linux内核优化中主要针对两个配置文件   /etc/security/limits.conf 和/etc/sysctl.conf 

通常是利用调用内核参数的程序sysctl -a 查询出最优内核参数，然后写入 /etc/sysctl.conf 文件内的。

[root@www opt]# sysctl -a |grep fs.file-max
fs.file-max = 197221     #查询出的文件句柄数量上限。
sysctl: reading key "net.ipv6.conf.all.stable_secret"
sysctl: reading key "net.ipv6.conf.default.stable_secret"
sysctl: reading key "net.ipv6.conf.ens33.stable_secret"
sysctl: reading key "net.ipv6.conf.lo.stable_secret"
sysctl: reading key "net.ipv6.conf.virbr0.stable_secret"
sysctl: reading key "net.ipv6.conf.virbr0-nic.stable_secret"

文件句柄
 

文件句柄（File Handle）是操作系统用于跟踪和管理打开的文件或资源的数据结构。
在操作系统中，每个打开的文件、网络连接、设备等都会被分配一个唯一的句柄，
操作系统通过这个句柄来标识和访问这些资源。

句柄数是指操作系统能够同时管理的句柄的数量。在一个计算机系统中，
许多应用程序和进程需要打开和使用文件、网络连接等资源。每个资源都需要一个句柄来进行操作。
如果系统的句柄数限制太低，就可能导致应用程序无法打开足够的文件、网络连接或其他资源，
从而影响系统的性能和可用性。

因此，调整句柄数的设置是确保系统能够处理并发连接和资源请求的重要一环。
在高负载的服务器环境中，适当地增加句柄数的限制可以提高系统的并发能力和性能。
但是过于激进地增加句柄数可能会消耗过多的系统资源，因此需要根据实际需求和硬件配置进行调整。

永久配置：

vim  /etc/security/limits.conf
# 65535 为Linux系统最大打开文件数
* soft nproc 65535 
* hard nproc 65535 
* soft nofile 65535 
* hard nofile 65535

* soft nproc 65535： 最大进程数软限制为 65535，即可以使用 ulimit -u 命令查看和修改的值。
* hard nproc 65535： 最大进程数硬限制为 65535，即最大可分配的进程数。
* soft nofile 65535：最大打开文件数软限制为 65535，即可以使用 ulimit -n 命令查看和修改的值。
* hard nofile 65535：最大打开文件数硬限制为 65535，即最大可分配的文件数。
这里使用的通配符 * 表示对所有用户生效。

其他调试内核参数的查看： sysctl -a

kernel.sysrq = 0: 禁用了内核的SysRq功能，SysRq允许在系统崩溃或出现问题时执行一些调试操作。

kernel.core_uses_pid = 1: 设置核心转储文件名中包含进程ID，有助于标识是哪个进程导致了核心转储。

kernel.msgmnb 和 kernel.msgmax: 增加IPC消息队列的默认和最大大小，用于进程间通信。

kernel.shmmax 和 kernel.shmall: 调整共享内存的最大大小和分配页面数。

net.ipv4.ip_forward = 0: 禁用IP数据包的转发功能，通常用于不充当路由器的系统。

net.ipv4.conf.default.rp_filter 和 net.ipv4.conf.all.rp_filter: 控制反向路径过滤，提高网络安全性。

net.ipv4.icmp_echo_ignore_all: 允许或禁止系统响应ping请求。

net.ipv4.icmp_echo_ignore_broadcasts: 禁止系统对广播和多播地址的ICMP回显和时间戳请求作出响应。

net.ipv4.conf.default.accept_source_route: 不接受源路由，增加网络安全性。

net.ipv4.tcp_syncookies = 1: 启用SYN Cookies，保护系统免受TCP SYN 攻击。

net.ipv4.tcp_max_tw_buckets = 6000: 设置允许的TIME_WAIT套接字最大数量，避免服务器性能下降。

net.ipv4.tcp_sack = 1: 启用有选择的应答（SACK）来提高TCP性能。

net.ipv4.tcp_window_scaling = 1: 启用TCP窗口缩放功能，允许大窗口的TCP传输。

net.ipv4.tcp_rmem, net.ipv4.tcp_wmem: 调整TCP套接字读取和写入缓冲区大小。

net.ipv4.tcp_mem: 设置TCP缓冲区的最小、默认和最大值。

net.core.wmem_default, net.core.rmem_default, net.core.rmem_max, net.core.wmem_max: 调整网络核心
缓冲区的大小。

net.core.netdev_max_backlog: 控制网络接口接收数据包的排队队列大小。

net.ipv4.tcp_max_orphans: 设置系统允许的孤立TCP连接最大数量。

net.ipv4.tcp_max_syn_backlog: 控制系统允许的三次握手队列长度。

net.ipv4.tcp_synack_retries 和 net.ipv4.tcp_syn_retries: 设置SYN-ACK和SYN请求的重试次数。

net.ipv4.tcp_tw_recycle 和 net.ipv4.tcp_tw_reuse: 启用TIME_WAIT套接字快速回收和重用。

net.ipv4.tcp_fin_timeout: 设置TCP连接FIN（关闭连接）的超时时间。

net.ipv4.tcp_keepalive_time: 设置TCP keepalive探测包发送频率，以检测连接状态。

net.ipv4.ip_local_port_range: 设置本地端口范围，用于分配本地应用程序端口。

net.ipv6.conf.all.disable_ipv6 和 net.ipv6.conf.default.disable_ipv6: 禁用IPv6。

net.netfilter.nf_conntrack_max 和其他 net.netfilter.nf_conntrack_*: 控制连接跟踪和防火墙相关设置。

net.nf_conntrack_max: 设置最大连接跟踪项数。

vm.overcommit_memory = 0: 控制内存超额分配策略，避免OOM killer杀掉进程。

vm.swappiness = 0: 设置内存交换行为，降低内存交换。

fs.file-max = 999999: 设置进程可以同时打开的最大文件句柄数。

net.ipv4.tcp_max_tw_buckets = 6000: 设置操作系统允许的TIME_WAIT套接字最大数量。

net.ipv4.ip_local_port_range = 1024 65000: 设置系统允许的本地端口范围。

net.ipv4.tcp_tw_recycle = 1: 启用TIME_WAIT套接字快速回收。

net.ipv4.tcp_tw_reuse = 1: 允许TIME-WAIT套接字重用。

net.ipv4.tcp_syncookies = 1: 启用SYN Cookies，防止TCP SYN 攻击。

net.core.somaxconn = 40960: 设置最大监听队列长度，用于控制最大并发连接数。

net.core.netdev_max_backlog = 262144: 设置每个网络接口接收数据包队列的最大大小。

net.ipv4.tcp_max_syn_backlog = 262144: 设置接受SYN请求队列的最大长度。

net.ipv4.tcp_rmem, net.ipv4.tcp_wmem: 设置TCP套接字读取和写入缓冲区的最小、默认和最大大小。

net.core.rmem_default, net.core.wmem_default, net.core.rmem_max, net.core.wmem_max: 设置内核套接字接收和
发送缓冲区大小。

net.ipv4.tcp_syncookies = 1: 设置启用SYN Cookies，用于解决TCP SYN 攻击。

查看指定的进程方法：
ps  -T -p   <pid号>

查看线程的方法：
ps  -aT

核心知识点：

Tomcat的核心组件和作用

请求过程中的数据流向也需要记住

1、用户在浏览器中输入网址，请求被发送到本机端口 8080，被在那里监听的 Connector 获得；

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

3、请求在 Engine、Host、Context 和 Wrapper 这四个容器之间层层调用，
最后在 Servlet 中执行对应的业务逻辑、数据存储等。

4、执行完之后的请求响应在 Context、Host、Engine 容器之间层层返回，最后返回给 Connector，
并通过 Connector 返回给客户端。

Tomcat配置和JVM优化，你是怎么做的？

配置优化：

常用的几个（记忆点）

最小空闲连接数（也就是最小空闲线程）

最大线程数（并发量）

最大备用线程

连接超时

反向查询

上传超时

上传超时时间

压缩

代码：

JAVA_OPTS="$JAVA_OPTS -server -Xms2048m -Xmx2048m -Xmn768m -XX:ParallelGCThreads=2 -XX:PermSize=1024m -XX:MaxPermSize=1024m -Djava.awt.headless=true -XX:+DisableExplicitGC" 

​​​​​​​