关于性能调优:肝了15000字性能调优系列专题JVMMySQLNginx-and-Tomcat看不完先收藏

性能调优，无疑是个宏大的话题，也是很多我的项目中十分重要的一环，性能调优难做是家喻户晓的，毕竟性能调优涵盖的面切实是太多了，在这里我就大略的讲一下企业中最罕用的四种调优——JVM 调优、MySQL 调优、Nginx 调优以及 Tomcat 调优，一家之言，有什么说的不对的还请多包涵补充。

篇幅所限，有些货色是必定写不到的，所以本文只是挑了一些重要局部来分析，如果须要残缺具体的把握性能调优，能够来支付零碎整顿的 性能调优笔记和相干学习材料

话不多说，坐稳扶好，发车喽！

如下图所示，JVM 类加载机制分为五个局部：加载，验证，筹备，解析，初始化，上面咱们就别离来看一下这五个过程。

在加载阶段，虚拟机须要实现以下三件事件：

1）通过一个类的全限定名来获取定义此类的二进制字节流。留神这里的二进制字节流不肯定非得要从一个 Class 文件获取，这里既能够从 ZIP 包中读取（比方从 jar 包和 war 包中读取），也能够从网络中获取，也能够在运行时计算生成（动静代理），也能够由其它文件生成（比方将 JSP 文件转换成对应的 Class 类）。

2）将这个字节流所代表的动态存储构造转化为办法区的运行时数据结构。

3）在 Java 堆中生成一个代表这个类的 java.lang.Class 对象，作为办法区这些数据的拜访入口。

绝对于类加载过程的其余阶段，加载阶段（精确地说，是加载阶段中获取类的二进制字节流的动作）是开发期可控性最强的阶段，因为加载阶段既能够应用零碎提供的类加载器来实现，也能够由用户自定义的类加载器去实现，开发人员们能够通过定义本人的类加载器去管制字节流的获取形式。

这一阶段的次要目标是为了确保 Class 文件的字节流中蕴含的信息是否合乎以后虚拟机的要求，并且不会危害虚拟机本身的平安。

筹备阶段是正式为类变量分配内存并设置类变量的初始值阶段，即在办法区中调配这些变量所应用的内存空间。留神这里所说的初始值概念，比方一个类变量定义为：

public static int v = 8080;

实际上变量 v 在筹备阶段过后的初始值为 0 而不是 8080，将 v 赋值为 8080 的 putstatic 指令是程序被编译后，寄存于类结构器 <client> 办法之中，这里咱们前面会解释。

然而留神如果申明为：

public static final int v = 8080;

在编译阶段会为 v 生成 ConstantValue 属性，在筹备阶段虚构机会依据 ConstantValue 属性将 v 赋值为 8080。

解析阶段是指虚拟机将常量池中的符号援用替换为间接援用的过程。符号援用就是 class 文件中的：

CONSTANT_Class_info
CONSTANT_Field_info
CONSTANT_Method_info

等类型的常量。

上面咱们解释一下符号援用和间接援用的概念：

符号援用与虚拟机实现的布局无关，援用的指标并不一定要曾经加载到内存中。各种虚拟机实现的内存布局能够各不相同，然而它们能承受的符号援用必须是统一的，因为符号援用的字面量模式明确定义在 Java 虚拟机标准的 Class 文件格式中。
间接援用能够是指向指标的指针，绝对偏移量或是一个能间接定位到指标的句柄。如果有了间接援用，那援用的指标必然曾经在内存中存在。

初始化阶段是类加载最初一个阶段，后面的类加载阶段之后，除了在加载阶段能够自定义类加载器以外，其它操作都由 JVM 主导。到了初始阶段，才开始真正执行类中定义的 Java 程序代码。

初始化阶段是执行类结构器 <clint> 办法的过程。<clint>办法是由编译器主动收集类中的类变量的赋值操作和动态语句块中的语句合并而成的。虚构机会保障 <clint> 办法执行之前，父类的 <clint> 办法曾经执行结束。p.s: 如果一个类中没有对动态变量赋值也没有动态语句块，那么编译器能够不为这个类生成 <clint>() 办法。

留神以下几种状况不会执行类初始化：

通过子类援用父类的动态字段，只会触发父类的初始化，而不会触发子类的初始化。
定义对象数组，不会触发该类的初始化。
常量在编译期间会存入调用类的常量池中，实质上并没有间接援用定义常量的类，不会触发定义常量所在的类。
通过类名获取 Class 对象，不会触发类的初始化。
通过 Class.forName 加载指定类时，如果指定参数 initialize 为 false 时，也不会触发类初始化，其实这个参数是通知虚拟机，是否要对类进行初始化。
通过 ClassLoader 默认的 loadClass 办法，也不会触发初始化动作。

虚拟机设计团队把类加载阶段中的“通过一个类的全限定名来获取形容此类的二进制字节流”这个动作放到 Java 虚拟机内部去实现，以便让应用程序本人决定如何去获取所须要的类。实现这个动作的代码模块被称为“类加载器”。

对于任意一个类，都须要由加载它的类加载器和这个类自身一起确立其在 Java 虚拟机中的唯一性。这句话能够表白得更艰深一些：比拟两个类是否“相等”，只有在这两个类是由同一个类加载器加载的前提之下才有意义，否则，即便这两个类是来源于同一个 Class 文件，只有加载它们的类加载器不同，那这两个类就必然不相等。这里所指的“相等”，包含代表类的 Class 对象的 equals()办法、isAssignableFrom()办法、isInstance()办法的返回后果，也包含了应用 instanceof 关键字做对象所属关系断定等状况。如果没有留神到类加载器的影响，在某些状况下可能会产生具备迷惑性的后果。

JVM 提供了 3 品种加载器：

启动类加载器 (Bootstrap ClassLoader)：负责加载 JAVA_HOME\lib 目录中的，或通过-Xbootclasspath 参数指定门路中的，且被虚拟机认可（按文件名辨认，如 rt.jar）的类。
扩大类加载器(Extension ClassLoader)：负责加载 JAVA_HOME\lib\ext 目录中的，或通过 java.ext.dirs 零碎变量指定门路中的类库。
应用程序类加载器(Application ClassLoader)：负责加载用户门路（classpath）上的类库。

JVM 通过双亲委派模型进行类的加载，当然咱们也能够通过继承 java.lang.ClassLoader 实现自定义的类加载器。

双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都该当有本人的父类加载器。这里类加载器之间的父子关系个别不会以继承（Inheritance）的关系来实现，而是都应用组合（Composition）关系来复用父加载器的代码。

双亲委派模型的工作过程是：如果一个类加载器收到了类加载的申请，它首先不会本人去尝试加载这个类，而是把这个申请委派给父类加载器去实现，每一个档次的类加载器都是如此，因而所有的加载申请最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈本人无奈实现这个加载申请（它的搜寻范畴中没有找到所需的类）时，子加载器才会尝试本人去加载。

采纳双亲委派的一个益处是比方加载位于 rt.jar 包中的类 java.lang.Object，不论是哪个加载器加载这个类，最终都是委托给顶层的启动类加载器进行加载，这样就保障了应用不同的类加载器最终失去的都是同样一个Object 对象。

在有些情境中可能会呈现要咱们本人来实现一个类加载器的需要，因为这里波及的内容比拟宽泛，我想当前独自写一篇文章来讲述，不过这里咱们还是略微来看一下。咱们间接看一下 jdk 中的 ClassLoader 的源码实现：

protected synchronized Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
    // First, check if the class has already been loaded
    Class c = findLoadedClass(name);
    if (c == null) {
        try {if (parent != null) {c = parent.loadClass(name, false);
            } else {c = findBootstrapClass0(name);
            }
        } catch (ClassNotFoundException e) {
            // If still not found, then invoke findClass in order
            // to find the class.
            c = findClass(name);
        }
    }
    if (resolve) {resolveClass(c);
    }
    return c;
}

首先通过 Class c = findLoadedClass(name); 判断一个类是否曾经被加载过。
如果没有被加载过执行 if (c == null) 中的程序，遵循双亲委派的模型，首先会通过递归从父加载器开始找，直到父类加载器是 Bootstrap ClassLoader 为止。
最初依据 resolve 的值，判断这个 class 是否须要解析。

而下面的 findClass() 的实现如下，间接抛出一个异样，并且办法是 protected，很显著这是留给咱们开发者本人去实现的，这里咱们当前咱们独自写一篇文章来讲一下如何重写findClass 办法来实现咱们本人的类加载器。

protected Class<?> findClass(String name) throws ClassNotFoundException {throw new ClassNotFoundException(name);
}

这几个存储区最次要的就是栈区和堆区，那么什么是栈什么是堆呢？说的简略点，栈外面寄存的是根本的数据类型和援用，而堆外面则是寄存各种对象实例的。

堆与栈离开设计是为什么呢？

栈存储了解决逻辑、堆存储了具体的数据，这样隔离设计更为清晰
堆与栈拆散，使得堆能够被多个栈共享。
栈保留了上下文的信息，因而只能向上增长；而堆是动态分配

栈的大小能够通过 -XSs 设置，如果有余的话，会引起 java.lang.StackOverflowError 的异样

线程公有，生命周期与线程雷同。每个办法执行的时候都会创立一个栈帧（stack frame）用于寄存局部变量表、操作栈、动静链接、办法进口。

寄存对象实例，所有的对象的内存都在这里调配。垃圾回收次要就是作用于这里的。

堆得内存由 -Xms 指定，默认是物理内存的 1 /64；最大的内存由 -Xmx 指定，默认是物理内存的 1 /4。
默认空余的堆内存小于 40% 时，就会增大，直到 -Xmx 设置的内存。具体的比例能够由 -XX:MinHeapFreeRatio 指定
空余的内存大于 70% 时，就会缩小内存，直到 -Xms 设置的大小。具体由 -XX:MaxHeapFreeRatio 指定。

因而个别都倡议把这两个参数设置成一样大，能够防止 JVM 在一直调整大小。

这里记录了线程执行的字节码的行号，在分支、循环、跳转、异样、线程复原等都依赖这个计数器。

类型信息、字段信息、办法信息、其余信息

有两种形式，一种是援用计数（然而无奈解决循环援用的问题）；另一种就是可达性剖析。

判断对象能够回收的状况：

显示的把某个援用置位 NULL 或者指向别的对象
部分援用指向的对象
弱援用关联的对象

这种办法长处就是缩小进展工夫，然而毛病是会造成内存碎片。

这种办法不波及到对象的删除，只是把可用的对象从一个中央拷贝到另一个中央，因而适宜大量对象回收的场景，比方新生代的回收。

这种办法能够解决内存碎片问题，然而会减少进展工夫。

最初的这种办法是后面几种的合体，即目前 JVM 次要采取的一种办法，思维就是把 JVM 分成不同的区域。每种区域应用不同的垃圾回收办法。

下面能够看到堆分成两个个区域：

新生代(Young Generation)：用于寄存新创建的对象，采纳复制回收办法，如果在 s0 和 s1 之间复制肯定次数后，转移到年轻代中。这里的垃圾回收叫做 minor GC;
年轻代(Old Generation)：这些对象垃圾回收的频率较低，采纳的标记整顿办法，这里的垃圾回收叫做 major GC。

这里能够具体的说一下新生代复制回收的算法流程：

在新生代中，分为三个区：Eden, from survivor, to survior。

当触发 minor GC 时，会先把 Eden 中存活的对象复制到 to Survivor 中；
而后再看 from survivor，如果次数达到年轻代的规范，就复制到年轻代中；如果没有达到则复制到 to survivor 中，如果 to survivor 满了，则复制到年轻代中。
而后调换 from survivor 和 to survivor 的名字，保障每次 to survivor 都是空的期待对象复制到那里的。

这种收集器就是以单线程的形式收集，垃圾回收的时候其余线程也不能工作。

以多线程的形式进行收集

大抵的流程为：初始标记 – 并发标记 – 从新标记 – 并发革除

大抵的流程为：初始标记 – 并发标记 – 最终标记 – 筛选回收

篇幅所限，对于类字节码文件、调优工具以及 GC 日志剖析这里就不写了，如果有感兴趣的敌人能够点击支付我整顿的残缺 JVM 性能调优笔记，外面会有具体叙述。

蕴含三大组件：

（1）命令解析器：查看语法和转换查问树。

（2）查问执行器：优化查问。

（3）查问优化器：负责执行查问。

蕴含三大组件：

（1）事务管理器：通过锁来治理数据及维持事务的 ACID 属性。

（2）数据拜访办法：解决对行、索引、页、行版本、空间调配等的 I / O 申请。

（3）缓冲区管理器：治理 SQL Server 的次要内存耗费组件 Buffer Pool。

蕴含 SQL Server 的所有缓存。如打算缓存和数据缓存。

记录事务的所有更改。保障事务 ACID 属性的重要组件。

数据库的物理存储文件。

6.SQL Server 网络接口
建设在客户端和服务器之间的网络连接的协定层

1.2.1 当客户端执行一条 T -SQL 语句给 SQL Server 服务器时，会首先达到服务器的网络接口，网络接口和客户端之间有协定层。

1.2.2 客户端和网络接口之间建设连贯。应用称为“表格格局数据流”(TDS) 数据包的 Microsoft 通信格局来格式化通信数据。

1.2.3 客户端发送 TDS 包给协定层。协定层接管到 TDS 包后，解压并剖析包外面蕴含了什么申请。

1.2.4 命令解析器解析 T -SQL 语句。命令解析器会做上面几件事件：

（1）查看语法。发现有语法错误就返回给客户端。上面的步骤不执行。

（2）查看缓冲池（Buffer Pool）中是否存在一个对应该 T -SQL 语句的执行打算缓存。

（3）如果找到已缓存的执行打算，就从执行打算缓存中间接读取，并传输给查问执行器执行。

（4）如果未找到执行打算缓存，则在查问执行器中进行优化并产生执行打算，寄存到 Buffer Pool 中。

1.2.5 查问优化器优化 SQL 语句

当 Buffer Pool 中没有该 SQL 语句的执行打算时，就须要将 SQL 传到查问优化器，通过肯定的算法，剖析 SQL 语句，产生一个或多个候选执行打算。选出开销最小的打算作为最终执行打算。而后将执行打算传给查问执行器。

1.2.6 查问执行器执行查问

查问执行器把执行打算通过 OLE DB 接口传给存储引擎的数据拜访办法。

1.2.7 数据拜访办法生成执行代码

数据拜访办法将执行打算生成 SQL Server 可操作数据的代码，不会理论执行这些代码，传送给缓冲区管理器来执行。

1.2.8 缓冲区管理器读取数据。

先在缓冲池的数据缓存中查看是否存在这些数据，如果存在，就把后果返回给存储引擎的数据拜访办法；如果不存在，则从磁盘（数据文件）中读出数据并放入数据缓存中，而后将读出的数据返回给存储引擎的数据拜访办法。

1.2.9 对于读取数据，将会申请共享锁，事务管理器调配共享锁给读操作。

1.2.10 存储引擎的数据拜访办法将查问到的后果返回关系引擎的查问执行器。

1.2.11 查问执行器将后果返回给协定层。

1.2.12 协定层将数据封装成 TDS 包，而后协定层将 TDS 包传给客户端。

个别的利用零碎，读写比例在 10:1 左右，而且插入操作和个别的更新操作很少呈现性能问题，在生产环境中，咱们遇到最多的，也是最容易出问题的，还是一些简单的查问操作，因而对查问语句的优化显然是重中之重。说起减速查问，就不得不提到索引了。

索引在 MySQL 中也叫做“键”或者 ”key”（primary key，unique key，还有一个 index key），是存储引擎用于疾速找到记录的一种数据结构。索引对于良好的性能十分要害，尤其是当表中的数据量越来越大时，索引对于性能的影响愈发重要，缩小 io 次数，减速查问。（其中 primary key 和 unique key，除了有减速查问的成果之外，还有束缚的成果，primary key 不为空且惟一，unique key 惟一，而 index key 只有减速查问的成果，没有束缚成果）

索引优化应该是对查问性能优化最无效的伎俩了。索引可能轻易将查问性能进步好几个数量级。
索引相当于字典的音序表，如果要查某个字，如果不应用音序表，则须要从几百页中逐页去查。

强调：一旦为表创立了索引，当前的查问最好先查索引，再依据索引定位的后果去找数据

索引的目标在于进步查问效率，与咱们查阅图书所用的目录是一个情理：先定位到章，而后定位到该章下的一个大节，而后找到页数。类似的例子还有：查字典，查火车车次，飞机航班等，上面内容看不懂的同学也没关系，能明确这个目录的情理就行了。那么你想，书的目录占不占页数，这个页是不是也要存到硬盘外面，也占用硬盘空间。

你再想，你在没有数据的状况下先建索引或者说目录快，还是曾经存在好多的数据了，而后再去建索引，哪个快，必定是没有数据的时候快，因为如果曾经有了很多数据了，你再去依据这些数据建索引，是不是要将数据全副遍历一遍，而后依据数据建设索引。你再想，索引建设好之后再增加数据快，还是没有索引的时候增加数据快，索引是用来干什么的，是用来减速查问的，那对你写入数据会有什么影响，必定是慢一些了，因为你凡是退出一些新的数据，都须要把索引或者说书的目录从新做一个，所以索引尽管会放慢查问，然而会升高写入的效率。

后面讲了索引的基本原理，数据库的复杂性，又讲了操作系统的相干常识，目标就是让大家理解，当初咱们来看看索引怎么做到缩小 IO，减速查问的。任何一种数据结构都不是凭空产生的，肯定会有它的背景和应用场景，咱们当初总结一下，咱们须要这种数据结构可能做些什么，其实很简略，那就是：每次查找数据时把磁盘 IO 次数管制在一个很小的数量级，最好是常数数量级。那么咱们就想到如果一个高度可控的多路搜寻树是否能满足需要呢？就这样，b+ 树应运而生。

即便咱们不会这些锁常识，咱们的程序在 个别状况下 还是能够跑得好好的。因为这些锁数据库隐式帮咱们加了

对于 UPDATE、DELETE、INSERT 语句，InnoDB会主动给波及数据集加排他锁（X)
MyISAM在执行查问语句 SELECT 前，会主动给波及的所有表加读锁，在执行更新操作（UPDATE、DELETE、INSERT 等）前，会主动给波及的表加写锁

只会在某些特定的场景下才须要手动加锁，学习数据库锁常识就是为了:

能让咱们在特定的场景下派得上用场
更好 把控本人写的程序
在跟他人聊数据库技术的时候能够搭上几句话
构建本人的知识库体系！在面试的时候不虚

首先，从锁的粒度，咱们能够分成两大类：

表锁
- 开销小，加锁快；不会呈现死锁；锁定力度大，产生锁抵触概率高，并发度最低
行锁
- 开销大，加锁慢；会呈现死锁；锁定粒度小，产生锁抵触的概率低，并发度高

不同的存储引擎反对的锁粒度是不一样的：

InnoDB 行锁和表锁都反对！
MyISAM 只反对表锁！

InnoDB 只有通过 索引条件 检索数据 才应用行级锁 ，否则，InnoDB 将应用表锁

也就是说，InnoDB 的行锁是基于索引的！

表锁下又分为两种模式：

表读锁（Table Read Lock）
表写锁（Table Write Lock）
从下图能够清晰看到，在表读锁和表写锁的环境下：读读不阻塞，读写阻塞，写写阻塞！
- 读读不阻塞：以后用户在读数据，其余的用户也在读数据，不会加锁
- 读写阻塞：以后用户在读数据，其余的用户 不能批改以后用户读的数据，会加锁！
- 写写阻塞：以后用户在批改数据，其余的用户 不能批改以后用户正在批改的数据，会加锁！
- 写锁和其余锁均布兼容，只有读和读之间兼容

从下面曾经看到了：读锁和写锁是互斥的，读写操作是串行。

如果某个过程想要获取读锁，同时另外一个过程想要获取写锁。在 mysql 里边，写锁是优先于读锁的！
写锁和读锁优先级的问题是能够通过参数调节的：max_write_lock_count和low-priority-updates

值得注意的是：

MyISAM 能够 反对查问和插入操作的并发进行。能够通过零碎变量 concurrent_insert 来指定哪种模式，在 MyISAM 中它默认是：如果 MyISAM 表中没有空洞（即表的两头没有被删除的行），MyISAM 容许在一个过程读表的同时，另一个过程从表尾插入记录。
然而InnoDB 存储引擎是不反对的！

3.3 MVCC 和事务的隔离级别

数据库事务有不同的隔离级别，不同的隔离级别对锁的应用是不同的，锁的利用最终导致不同事务的隔离级别

MVCC(Multi-Version Concurrency Control)多版本并发管制，能够简略地认为：MVCC 就是行级锁的一个变种(升级版)。

事务的隔离级别就是通过锁的机制来实现，只不过暗藏了加锁细节
在表锁中咱们读写是阻塞的，基于晋升并发性能的思考，MVCC 个别读写是不阻塞的(所以说 MVCC 很多状况下防止了加锁的操作)
MVCC 实现的读写不阻塞正如其名：多版本并发管制 —> 通过肯定机制生成一个数据申请工夫点的一致性数据快照（Snapshot)，并用这个快照来提供肯定级别（语句级或事务级）的一致性读取。从用户的角度来看，如同是数据库能够提供同一数据的多个版本。
快照有两个级别：
语句级
针对于 Read committed 隔离级别
事务级别
针对于 Repeatable read 隔离级别
咱们在初学的时候曾经晓得，事务的隔离级别有 4 种：
Read uncommitted
会呈现脏读，不可反复读，幻读
Read committed
会呈现不可反复读，幻读
Repeatable read
会呈现幻读(但在 Mysql 实现的 Repeatable read 配合 gap 锁不会呈现幻读！)
Serializable

串行，防止以上的状况！

Read uncommitted 会呈现的景象 —> 脏读：一个事务读取到另外一个事务未提交的数据
例子：A 向 B 转账，A 执行了转账语句，但 A 还没有提交事务，B 读取数据，发现自己账户钱变多了！B 跟 A 说，我曾经收到钱了。A 回滚事务【rollback】，等 B 再查看账户的钱时，发现钱并没有多。
呈现脏读的实质就是因为操作 (批改) 完该数据就立马开释掉锁，导致读的数据就变成了无用的或者是谬误的数据。
Read committed 防止脏读的做法其实很简略：
就是把开释锁的地位调整到事务提交之后，此时在事务提交前，其余过程是无奈对该行数据进行读取的，包含任何操作
但 Read committed 呈现的景象 —> 不可反复读：一个事务读取到另外一个事务曾经提交的数据，也就是说一个事务能够看到其余事务所做的批改
注：A 查询数据库失去数据，B 去批改数据库的数据，导致 A 屡次查询数据库的后果都不一样【危害：A 每次查问的后果都是受 B 的影响的，那么 A 查问进去的信息就没有意思了】
下面也说了，Read committed 是语句级别的快照！每次读取的都是以后最新的版本！

Repeatable read 防止不可反复读是事务级别的快照！每次读取的都是以后事务的版本，即便被批改了，也只会读取以后事务版本的数据。

呃 … 如果还是不太分明，咱们来看看 InnoDB 的 MVCC 是怎么样的吧(摘抄《高性能 MySQL》)

InnoDB 的 MVCC，是通过在每行记录前面保留两个暗藏的列来实现的，这两个列一个保留了行的创立工夫，一个保留了行的过期（删除）工夫。当然存储的并不是真正的工夫值，而是零碎版本号。每开始一个新的事务，零碎版本号会主动递增，事务开始的时候的零碎版本号会作为事务的版本号，用来和查问到的每行记录的版本号进行比拟。
select
InnoDB 会依据以下两个条件查看每行记录：
a. InnoDB 只查找版本早于以后事务版本的数据行，这样能够确保事务读取到的数据，要么是在事务开始前就存在的，要么是事务本身插入或更新的
b. 行的删除版本要么未定义要么大于以后事务版本号，确保了事务读取到的行，在事务开始前未被删除

至于虚读(幻读)：是指在一个事务内读取到了别的事务插入的数据，导致前后读取不统一。

注：和不可反复读相似，但虚读 (幻读) 会读到其余事务的插入的数据，导致前后读取不统一
MySQL 的 Repeatable read 隔离级别加上 GAP 间隙锁曾经解决了幻读了。

nginx 罕用做动态内容服务和反向代理服务器，以及页面前端高并发服务器。适宜做负载平衡，直面外来申请转发给前面的应用服务（tomcat 什么的）

user  root;  #运行 worker 过程的账户，user   用户   [组]，默认以 nobody 账户运行
worker_processes  7;  #要应用的 worker 过程数，可设置为数值、auto（依据机器性能主动设置），默认值 1

error_log  logs/error.log;  #nginx 过程（master+worker）的日志设置，保留地位、输入级别，此即为默认保留地位
#error_log  logs/error.log  notice;  #输入级别可选，由低到高顺次为：debug（输入信息最多），info，notice，warn，error，erit（输入信息起码）pid  logs/nginx.pid;  #nginx 主过程的 pid 的保留地位，此即为默认值

worker_rlimit_nofile 65535;  #单个 worker 过程可关上的最大文件描述符数

worker_processes：

理论经营时个别设置为很靠近 CPU 的线程数，比如说 CPU 是 8 线程，个别设置为 6、7。

咱们本人开发、用时个别设置为 1、2 即可，不然太吃资源。

worker_rlimit_nofile：

r 是 read，limit 是限度，单个 worker 过程最多只能关上指定个数的文件，超过便不能再读取文件。关上一次文件便会产生一个文件描述符。

此设置是为了避免单个 worker 过程耗费大量的系统资源。

ps -ef | grep nginx 查问下 nginx 的过程：

不论设置多少个 worker 过程，主过程只有一个（即运行 sbin/nginx）。

主过程由 Linux 以后登录的账户运行，工作过程由 user 指令指定的账户运行。第一列数字是过程的 PID。

nginx 工作过程和 nginx 主过程都是 Linux 中的过程，但主过程（父过程）能够管制 worker 过程（子过程）的开启、完结。

master 过程能够看做老板，worker 过程能够看做打工仔。

events {
   accept_mutex on;  #避免惊群
   multi_accept on;  #容许单个 worker 过程可同时接管多个网络连接的申请，默认为 off
  use epoll;  #设置 worker 过程应用高效模式
   worker_connections 1024;  #指定单个 worker 过程最多可建设的网络连接数，默认值 1024。}

accept_mutex：

惊群景象：一个网络连接到来，所有沉睡的 worker 过程都会被唤醒，但只用一个 worker 解决连贯，其余被唤醒的 worker 又开始沉睡。

设置为 on：要应用几个 worker 就唤醒几个，不全副唤醒，默认值就是 on。

设置为 off：一律全副唤醒。一片 worker 醒来是要占用资源的，会影响性能。

use：

指定 nginx 的工作模式，可选的值：select、poll、kqueue、epoll、rtsig、/dev/poll。

其中 select、poll 都是规范模式，kqueue、epoll 都是高效模式，

kqueue 是在 BSD 零碎中用的，epoll 是在 Linux 零碎中用的。（BSD 是 Unix 的一个分支，Linux 是一品种 Unix 零碎）。

全局块中的 worker_processes、events 块中的 worker_connections 是 nginx 反对高并发的要害，这 2 个数值相乘即 nginx 可建设的最大连接数。

一个连贯要用一个文件来保留，

worker_connections 设置的单个 worker 过程的最大连接数，受全局块中 worker_rlimit_nofile 设置的单个 worker 过程可关上的最大文件数限度。

而 worker_rlimit_nofile 只是 nginx 对单个 worker 过程的限度，要受 Linux 系统对单个过程可关上的最大文件描述符数限度。

Linux 默认单个过程最多只能关上 1024 个文件描述符，须要咱们批改下 Linux 的资源限度，设置单个过程可关上的最大文件描述符数：

ulimit -n 65536

ulimit 命令能够限度单个过程应用的系统资源的尺寸、数量，包含内存、缓冲区、套接字、栈、队列、CPU 占用工夫等。

可用 ulimit –help 查看参数。

http{
    #http 全局块
    #server 块
}

能够有多个 server 块。

http 全局块的配置作用于整个 http 块（http 块内的所有 server 块）。

include       mime.types;  #将 conf/mime.types 蕴含进来
    default_type  application/octet-stream;  #设置默认的 MIME 类型，二进制流。如果应用的 MIME 类型在 mime.types 中没有，就当作默认类型解决。#log_format  main  '$remote_addr - $remote_user [$time_local]"$request" '  
    #                '$status $body_bytes_sent"$http_referer" '
    #                '"$http_user_agent" "$http_x_forwarded_for"';   access_log logs/access.log; #设置日志，这个日志保留的是客户端申请的信息，包含客户端地址、应用的浏览器、浏览器内核版本、申请的 url、申请工夫、申请形式、响应状态等。#access_log  logs/access.log  main;  #可指定日志格局，下面定义的 main 格局即默认格局。保留地位默认是 logs/access.log

    sendfile         on;  #开启文件高效传输模式，默认为 off，不开启。#tcp_nopush      on;  #如果响应体积过大，默认会分多个批次传输给客户端，设置为 on 会一次性传给客户端，可防止网络阻塞
   #tcp_nodelay     on;   #如果响应体积过小，默认会放在缓冲区，缓冲区满了才刷给客户端，设置为 on 间接刷给客户端，可防止网络阻塞
    keepalive_timeout  65;  #与客户端放弃连贯的超时工夫，在指定工夫内，如果客户端没有向 Nginx 发送任何数据（无流动），Nginx 会敞开该连贯。gzip  on;  #应用 gzip 模块压缩响应数据。启用后响应体积变小，传输到客户端所需工夫更少，节俭带宽，但 nginx 压缩、客户端解压都有额定的工夫、资源开销，nginx 的累赘也会加大。upstream  servers{  #设置负载均衡器，可同时设置多个负载均衡器。负载均衡器的名称中不能含有_，此处指定名称为 servers
        server  192.168.1.7:8080;  #tomcat 服务器节点
        server  192.168.1.8:8081;        server  192.168.1.7:8080 down;  #down 示意该节点下线，暂不应用     server  192.168.1.8:8081 backup;  #backup 示意该节点是备胎，只有在其余节点忙不过来时才会启用（比方一些节点出故障了、其余节点负载变大）。server  192.168.1.8:8081 max_fails=3  fail_timeout=60s;  #如果对该节点的申请失败 3 次，就 60s 内临时不应用该节点，60s 后复原应用
    }

日志格局罕用的值：

$remote_addr 客户端的 ip 地址
$time_local：拜访工夫与时区
$request：申请的 url 与 http 协定
$status：申请状态，胜利是 200
$http_referer：从那个页面链接拜访过去的
$http_user_agent：客户端浏览器的信息

server{     #server 全局块     listen       80;  #要监听的端口
        server_name  localhost;  #虚拟主机（即域名），要在 dns 上注册过才无效，没有注册的话只能用 localhost。可指定多个虚拟主机，空格离开即可
        charset utf-8;  #应用的字符集。#access_log  logs/host.access.log  main;  #在 http 全局块、server 全局块中任意一处设置日志即可。http 全局块曾经设置了日志，此处可不必设置。#谬误页设置     error_page  404  /404.html;  #html 目录下默认只有 index.html(nginx 首页)、50x.html，须要本人写 404.html        location = /404.html {root   html;  #指定 404.html 所在目录，此处应用相对路径，nginx 主目录下的 html 目录，也能够应用绝对路径}
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {root   html;}     #解决动态资源     location ~* \.(html|css|js|gif|jpg|png|mp4)$ {#应用正则表达式匹配 url，如果申请的是这些文件，就应用上面的解决形式            root static;    #如果应用 nginx 解决动态资源，需应用 root 指定动态资源所在目录。在 nginx 主目录下新建目录 static，把动态资源放进去即可。expires 30d;  #设置缓存过期工夫             #proxy_pass http://192.168.1.10:80;  #如果应用 apache 等其余机器解决动态资源，应用 proxy_pass 转发过来即可，多台机器集群时应用负载均衡器即可。}
         #设置默认解决形式     location / {#如果 url 没有指定匹配，就应用默认的解决形式来解决            root   html;  #指定解决申请的根目录。nginx 自身作为 web 服务器间接解决客户端申请时，比方申请 login.jsp，会调用 root 指定目录下的 login 来解决申请。index  index.html index.htm;  #指定 nginx 服务器的首页地址。root、index2 项配置都是必须的。proxy_pass http://servers; #指定要应用的负载均衡器，转发给其中某个节点解决。如不设置此项（代理），则默认 nginx 自身作为 web 服务器，间接解决申请，会到 root 指定目录下找申请的文件}
    }

设置的谬误页面是 nginx 作为 web 服务器（解决动态资源）呈现问题时，比方 nginx 上的动态资源找不到，返回给客户端的。

如果是 tomcat 呈现的问题，比方 tomcat 上的 xxx.jsp 找不到，返回的是 tomcat 的谬误页面，不是 nginx 的。

如果应用 nginx 自身要作为 web 服务器，间接解决客户端申请，比方解决动态资源，要将全局块中 user 设置为运行 nginx 的账户（即以后登陆 Linux 的账户），

否则 worker 过程（默认 nobody 账户）无权限读取以后账户（即运行 nginx 主过程的账户）的动态资源，客户端会显示 403 禁止拜访。

能够应用正则表达式来过滤客户端 ip，也能够把客户端的 ip 过滤规定写在文件中，而后蕴含进来。

（1）轮询

将列表中的服务器排成一圈，从前往后，找闲暇的服务器来解决申请。

轮询适宜服务器性能差不多的状况。默认应用的就是轮询，不须要设置什么。

（2）加权轮询

upstream  servers{
    server  192.168.1.7:8080 weight=1;
    server  192.168.1.8:8081 weight=2;
}

设置权重，权重大的轮到的机会更大，适宜服务器性能有显著差异的状况。

（3）ip_hash

upstream  servers{
    ip_hash;
    server  192.168.1.7:8080;
    server  192.168.1.8:8081;
}

依据客户端 ip 的 hash 值来转发申请，同一客户端（ip）的申请都会被转发给同一个服务器解决，可解决 session 问题。

（4）url_hash（第三方）

upstream  servers{
    hash $request_uri;
    server  192.168.1.7:8080;
    server  192.168.1.8:8081;
}

依据申请的 url 来转发，会将 url 雷同的申请转发给同一服务器解决。

始终解决某个 url，服务器上个别都有该 url 的缓存，可间接从缓存中获取数据作为响应返回，缩小工夫开销。

（5）fair（第三方）

upstream  servers{
    fair;
    server  192.168.1.7:8080;
    server  192.168.1.8:8081;
}

依据服务器响应工夫来散发申请，响应工夫短的散发的申请多。

fair 偏心，nginx 先计算每个节点的均匀响应工夫，响应工夫短阐明该节点负载小（闲），要多转发给它；响应工夫长阐明该节点负载大，要少转发给它。

ip_hash、url_hash 都是应用特定节点来解决特定申请，如果特定节点故障，nginx 会剔除不可用的节点，将特定申请转发给其它节点解决，url_hash 影响不大，但 ip_hash 会失落之前的 session 数据。

在 server.xml 中配置：

maxThreads:Tomcat 应用线程来解决接管的每个申请。这个值示意 Tomcat 可创立的最大的线程数。
acceptCount:指定当所有能够应用的解决申请的线程数都被应用时，能够放到解决队列中的申请数，超过这个数的申请将不予解决。
connnectionTimeout:网络连接超时，单位：毫秒。设置为 0 示意永不超时，这样设置有隐患的。通常可设置为 30000 毫秒。
minSpareThreads:Tomcat 初始化时创立的线程数。

maxSpareThreads:一旦创立的线程超过这个值，Tomcat 就会敞开不再须要的 socket 线程

tomcat 默认的 http 申请解决模式是 bio（即阻塞型，上面第二种），每次申请都新开一个线程解决。上面做一个介绍

<Connector port="8081" protocol="org.apache.coyote.http11.Http11NioProtocol" 
  connectionTimeout="20000" redirectPort="8443"/>

<Connector port="8081" protocol="HTTP/1.1" connectionTimeout="20000"
  redirectPort="8443"/>

<Connector executor="tomcatThreadPool"
  port="8081" protocol="HTTP/1.1"
  connectionTimeout="20000"
  redirectPort="8443" />

<Connector executor="tomcatThreadPool"
  port="8081" protocol="org.apache.coyote.http11.Http11NioProtocol"
  connectionTimeout="20000"
  redirectPort="8443" />

咱们权且把下面四种 Connector 依照程序命名为 NIO, HTTP, POOL, NIOP。测试性能比照，数值为每秒解决的申请数，越大效率越高

65 208 365
66 110 398
65 66 263
63 94 459

67 145 363

得出结论：NIOP > NIO > POOL > HTTP 尽管 Tomcat 默认的 HTTP 效率最低，然而依据测试次数能够看出是最稳固的。且这只是一个简略页面测试，具体会依据复杂度有所稳定。

配置参考：Linux 零碎每个过程反对的最大线程数是 1000，windos 是 2000。具体跟服务器的内存，Tomcat 配置的数量有关联。

<Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"
              maxThreads="500" minSpareThreads="25" maxSpareThreads="250"
              enableLookups="false" redirectPort="8443" acceptCount="300" connectionTimeout="20000" disableUploadTimeout="true"/>

Tomcat 的部署，是一台服务器部署一个 Tomcat（上线多个我的项目），还是一台服务器部署多个 tomact（每个 tomcat 部署 1~n 个我的项目）。多核必选配置多个 Tomcat，微服务多线程的思维模式。

批改 /bin/catalina.sh，减少如下设置：

JAVA_OPTS='-Xms【初始化内存大小】-Xmx【能够应用的最大内存】'

须要把这个两个参数值调大，大小的能够依据服务器内存的大小进行调整。例如：

JAVA_OPTS='-Xms1024m –Xmx2048m'

服务器是 8G 内存，跑了 3 个 tomcat 服务，给调配了 2G 的内存，因为还有其余过程。

本篇文章写到这里差不多就完结了，当然也有很多货色还没有写到，不过限于篇幅也是没辙，我整顿了很具体的JVM、MySQL、NGINX 和 Tomcat 的学习笔记以及材料, 须要的敌人间接点击支付就能够了。

最初，码字不易，所以，能够点个赞和珍藏吗兄弟们！

end

前言

一、Jvm 性能调优

1、JVM 类加载机制详解

1.1 加载

1.2 验证

1.3 筹备

1.4 解析

1.5 初始化

1.6 类加载器

2、JVM 内存模型

2.1 各局部的性能

栈区

堆

2.2 程序计数器

2.3 办法区

2.4 总结

3、垃圾收集机制详解

3.1 如何定义垃圾

3.2 垃圾回收的办法

3.2.1Mark-Sweep 标记 - 革除算法

3.2.2 Copying 复制算法

3.2.3 Mark-Compact 标记 - 整顿算法

3.2.4 Generational Collection 分代收集

3.3 垃圾回收器

3.3.1 串行收集器 Serial

3.3.2 并行收集器 Parallel

3.3.3 并发标记革除收集器 Concurrent Mark Sweep Collector, CMS

3.3.4 G1 收集器 Garbage First Collector

二、Mysql 性能调优

1、SQL 执行原理详解

1.1 SQL Server 组成部分

1.1.1 关系引擎：次要作用是优化和执行查问。

1.1.2 存储引擎：治理所有数据及波及的 IO

1.1.3Buffer Pool

1.1.4 事务日志

1.1.5 数据文件

1.2 查问的底层原理

2、索引底层分析

2.1 为何要有索引?

2.2 什么是索引？

2.3 索引原理

2.4 索引的数据结构

3、Mysql 锁机制与事务隔离级别详解

3.1 为什么须要学习数据库锁常识

3.2 表锁简略介绍

3.3 MVCC 和事务的隔离级别

串行，防止以上的状况！

三、Nginx 调优

1、Nginx 定义

2、熟练掌握 Nginx 外围配置

2.1 全局配置块

2.2 events 块

2.3 http 块

（1）http 全局块

（2）server 模块

3、把握 Nginx 负载算法配置

四、Tomcat 调优

1、根底参数设置

2、Tomat 的 4 种连贯形式比照

3、Tomcat 的集群

4、Tomcat 内存设置