上一篇：晚期（运行期）优化：https://blog.csdn.net/pcwl1206/article/details/84642835
目 录：
1 概述
衡量一个服务性能的高低好坏，每秒事务处理数（Transactions Per Second TPS）是最重要的指标之一，它代表一秒内服务端平均能响应的请求总数。
硬件的效率与一致性
处理器和内存不是同数量级，所以需要在中间建立中间层，也就是高速缓存，这会引出缓存一致性问题。在多处理器系统中，每个处理器都有自己的高速缓存，而它们又共享同一主内存（Main Memory）,有可能操作同一位置引起各自缓存不一致，这时候需要约定协议在保证一致性，这类有MSI、MESI、MOSI、Synapse、Firefly、 Dragon Protocol。
为了使得处理器内部的运算单元尽量被充分利用，处理器可能会对输入代码进行乱序执行优化（Out-Of-Order Execution）,指令重排序优化
2 Java内存模型
Java内存模型(Java Memory Model，JMM)：屏蔽掉了各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致性的内存访问效果。
2.1 主内存与工作内存
Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。此处变量不同于java的变量。它包括了实例字段、静态字段和构成数组对象的元素，但是不包含局部变量与方法参数，因为后者是线程私有的，不会被共享，自然就不存在竞争问题。
Java内存模型规定了所有的变量都存储在主内存（Main Memory）中，每个线程有自己的工作线程（Working Memory），保存主内存副本拷贝和自己私有变量，不同线程不能访问工作内存中的变量。线程间变量值的传递需要通过主内存来完成。
线程、主内存、工作内存交互关系图如下所示：
2.2 内存间交互操作
关于主内存与工作内存之间的具体的交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步主内存之类的实现细节，java内存模型中定义一下八种操作来完成：
1、lock(锁定)： 作用于主内存的变量。它把一个变量标志为一个线程独占的状态；
2、unlock(解锁)：作用于主内存的变量，它把处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定；
3、read(读取)：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用；
4、load(载入)： 作用于工作内存的变量，它把read操作从主内存中得到变量值放入工作内存的变量的副本中；
5、use(使用)： 作用于工作内存的变量， 它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作；
6、assign(赋值)： 作用于工作内存的变量。它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到需要给一个变量赋值的字节码时执行这个操作；
7、store(存储)：作用于工作内存的变量。它把一个工作内存中一个变量的值传递到主内存中，以便随后的write操作使用；
8、write(写入)： 作用于主内存的变量。 它把store操作从工作内存中得到的变量的值放入主内存的变量中。
如果要把一个变量从工作内存复制到工作内存，那就要按顺序执行read和load操作，如果要把变量从工作内存同步回主内存，就要按顺序执行store和write操作。
上诉8种基本操作必须满足的规则：
1、不允许read和load、store和write操作之一单独出现；
2、不允许一个线程丢弃它的最近的assign操作，即变量在工作内存中改变之后必须把该变化同步回主内存；
3、不允许一个线程无原因地（没有发生过任何assign操作）把数据从线程的工作内存同步回主内存中；
4、一个新的变量只能在主内存中“诞生”，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量，换句话说就是对一个变量实施use和store操作之前，必须执行过了assign和load 操作；
5、一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一线程重复执行多次，多次执行lock后，只有执行相同次数的unlock，变量才会被解锁；
6、如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值；
7、如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定主的变量；
8、对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store和write操作）。
2.3 对于volatile型变量的特殊规则
关键字volatile可以说是Java虚拟机提供的最轻量级的同步机制。
当一个变量定义为volatile后，它将具备两种特性：
1、保证此变量对所有线程的可见性；
2、禁止指令重排序优化；
1、保证此变量对所有线程的可见性
这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。而普通变量不能做到这一点，普通变量的值在线程间传递均需要通过主内存来完成，例如：线程A修改了一个普通变量的值，然后向主内存进行回写，另外一条线程B在线程A回写完成了之后再从主内存进行读取操作，新变量值才会对线程B可见。
“基于volatie变量的运算符在并发下是安全的”这个结论是错误的：Java里面的运算符非原子操作，导致volatile变量的运算在并发下一样是不安全的，下面进行案例演示：
public class VolatileTest {
public static volatile int race = 0;
public static void increase(){
race++;
}
private static final int THREADS_COUNT =20;
public static void main(String[] args) {
Thread[] threads = new Thread[THREADS_COUNT];
for (int i = 0; i < THREADS_COUNT; i++){
threads[i] = new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 10000; i++){
increase();
}
}
});
threads[i].start();
}
// 等待所有累加线程都结束
while (Thread.activeCount() > 1){
Thread.yield();
System.out.println(race);
}
}
}
这段代码发起了20个线程，每个线程对race变量进行10000次自增操作，如果这段代码能够正确并发的话，最后输出的结果应该是200000。但是实际运行结果都是一个小于200000的数字。很明显这是并发引起的错误。看下面VolatileTest的字节码：
当getstatic指令把race的值取到操作数栈时，volatile关键字保证了race的值在此时是正确的，但是在执行iconst_1、iadd这些指令的时候，其他线程可能已经把race的值加大了，而在操作数栈顶的值就变成了过期的数据，所以putstatic指令执行后就可能把较小race值同步回主内存中。
由于volatile变量只能保证可见性，在不符合以下两条规则的运算场景中，我们仍然要通过加锁（使用synchronized或java.util.concurrent中的原子类）来保证原子性。
1、运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值；
2、变量不需要与其他的状态变量共同参与不变约束。
2、禁止指令重排序优化
普通的变量仅仅会保证在该方法执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码执行顺序一致。因为在一个线程的方法执行过程中无法感知到这点，这也就是Java内存模型中描述的所谓的“线程内表现为串行的语义”。
下面通过一个案例来说明：重排序会干扰程序的并发执行。
Map configOptions
char[] configText;
//此变量必须定义为volatile
volatile boolean initialized = false；
//假设以下代码在线程A中执行
//模拟读取配置信息，当读取完成后
//将initialized设置为true来通知其他线程配置可用
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfigOptions (configText, configOptions);
initialized = true;
//假设以下代码在线程B中执行
//等待initialized为true，代表线程A已经把配置信息初始化完成
while (!initialized){
sleep();
}
//使用线程A中初始化好配置信息
doSomethingWithConfig();
如果定义initialized变量时没有使用volatile修饰，就可能会由于指令重排序优化，导致位于线程A中的最后一句代码“initialized = true;”被提前执行，这样在线程B中使用配置信息的代码就可能出现错误，而volatile关键字则可以避免此类情况的发生。
指令重排序优化不会执行。volatile开销小于锁。
说明：volatile在后面的Java并发编程中再做具体讲解，这里先简单了解下。
2.4 对于long和double型变量的特殊规则
Java内存模型要求lock、unlock、read、load、assign、use、store和write这个八个操作都具有原子性，但是对于64位的数据类型（long和double），在模型中特别定义了一条宽松的规定：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行，即允许虚拟机实现选择可以不保证64位数据类型的load、store、read和write这4个操作的原子性，这点就是所谓的long和double的非原子性协定。
如果有多个线程共享一个并未声明为volatile的long或double类型的变量，并且同时对它们进行读取和修改操作，则有可能读取一半数据是已经被其他线程修改过的。然而，在实际开发中，各种商用虚拟机几乎都选择把64为数据的读写操作作为原子操作对待，所以不需要专门为long和double变量专门声明为volatile。
2.5 原子性、可见性和有序性
Java内存模型是围绕着在并发过程中如何处理原子性、可见性和有序性这3个特征来建立的。
1、原子性
原子性（Atomicity）: 由Java内存模型来直接保证的原子性变量操作包括read、load、assign、use、store、write。
如果应用场景需要一个更大范围的原子性保证，Java内存模型还提供了lock和unlock操作来满足这种需求，尽管虚拟机并未把lock和unlock操作直接开放给用户使用，但是却提供了更高层次的字节码指令monitorenter和monitorexit来隐式地使用这两个操作，这两个字节码反映到Java代码中就是同步快—synchronized关键字，因此在synchronized块之间的操作也具备原子性。
2、可见性
可见性（Visibility）： 一个线程改变了共享变量的值会立即刷新到主内存中，其他线程会立即得知这个修改。
除了volatile之外，java还有两个关键字能实现可见性，它们是synchronized和final。同步块的可见性是由“对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store、write操作）”这条规则获得的。而final关键字的可见性是指：被final修饰的字段在构造器中一旦初始化完成，并且构造器没有把“this”的引用传递出去，那在其他线程中就能看见final字段的值。
3、有序性
有序性（Ordering）：Java程序中天然的有序性可以总结为一句话：“如果在本线程内观察，所有的操作都是有序的，如果在一个线程中观察另一个线程，所有操作都是无序的”。前半句线程内表现为串行的语义，后半句是指指令重排序现象和工作内存与主内存同步延迟现象。
volatile关键字本身包含了禁止指令重排序的语义，而synchronized则是有一个变量在同一时刻只允许一条线程对其进行lock操作获得有序性，这条规则决定了持有同一个锁的两个同步块只能串行地进入。
从上面的分析可以看出，使用synchronized关键字都可以实现原子性、可见性和有序性。
2.6 先行发生原则
先行发生(happens-before)原则：判断数据是否存在竞争、线程是否安全的主要依据，依靠这个原则，我们可以通过几条规则一揽子地解决并发环境下两个操作之间是否可能存在冲突的所有问题。
先行发生是Java内存模型中定义的两项操作之间的偏序关系，如果说操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响能被操作B观察到，“影响”包括修改了内存中共享变量的值、发生子消息、调用了方法等等。
Java内存模型中“天然的”一些先行发现原则，也就是程序默认执行顺序：
1、程序次序规则（Program Order Rule） : 在本线程内按程序代码顺序执行（准确说是按照控制流顺序）；
2、管理锁定原则（Monitor Lock Rule）： 一个unlock操作先行发生于后面对同一个锁的lock操作，这个必须强调的是同一个锁，必须在unlock才能lock操作；
3、volatile变量规则（Volatile Variable Rule）：对一个volatile变量的写操作先行发生于后面对这个变量的读操作；
4、线程启动规则（Thread Start Rule）：Thread对象的start()方法先行发生于此线程的每一个动作；
5、线程终止规则（Thread Termination Rule）： 线程中所有操作都先行发生于对此线程的终止检测；
6、线程中断规则（Thread Interruption Rule）： 对线程interrupt()方法的调用先行发生于被中断线程的代码检测中断事件的发生，可以通过Thread.interrupted()方法检测到是否有中断发生；
7、对象终结规则（Finalizer Rule）： 一个对象初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始；
8、传递性（Transitivity）： 如果操作A先行于发生于操作B，操作B先行发生于操作C、那就可以得出操作A先行于操作C的结论。
需要说明一点：时间上的先后顺序与先行发生原则之间基本没有太大关系，所以我们衡量并发安全问题的时候不要受到时间顺序的干扰，一切必须以先行发生原则为准。
3 Java与线程
3.1 线程的实现
线程是比进程更轻量级的调度执行单位，线程的引入，可以把一个进程的资源分配和执行调度分开，各个线程既可以共享进程资源（内存地址、文件I/O等），又可以独立调度（线程是CPU调度的基本单位）。
每个已经执行start()且还未结束的java.lang.Thread类的实例就代表了一个线程。
实现线程主要有3种方式：使用内核线程实现、使用用户线程实现和使用用户线程加轻量级进程混合实现。
3.1.1 使用内核线程实现
内核线程（Kernel Thread， KLT）就是直接由操作系统内核（Kernel）支持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器对线程进行调度，并且负责将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身，这样操作系统就有能力同时处理多件事情，支持多线程的内核就叫做多线程内核。
程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口—轻量级进程（Light Weight Process LWP），轻量级进程与内核线程之间1:1关系为一对一的线程模型。
由于内核线程的支持，每个轻量级进程都成为一个独立的调度单元，即使有一个轻量级进程在系统调用中阻塞了，也不会影响整个进程继续工作。
但是轻量级进程也有局限性：首先，由于是基于内核线程实现的，所以各种线程操作，如创建、析构及同步，都需要进行系统调用。 而系统调用的代价相对较高，需要在用户态（User Mode）和内核态（KernelMode）中来回切换。其次，每个轻量级进程都需要有一个内核线程的支持，因此轻量级进程要消耗一定的内核资源（如内核线程的栈空间），因此一个系统支持轻量级进程的数量有限。
3.1.2 使用用户线程实现
狭义上的用户线程指的是完全建立在用户空间的线程库上，系统内核不能感知线程存在的实现。用户线程的建立、 同步、 销毁和调度完全在用户态中完成，不需要内核的帮助。如果程序实现得当，这种线程不需要切换到内核态，因此操作可以是非常快速且低消耗的，也可以支持规模更大的线程数量，部分高性能数据库中的多线程就是由用户线程实现的。这种进程与用户线程之间1：N的关系称为一对多的线程模型。
用户线程的优势在于不需要系统内核支援，劣势也在于没有系统内核的支援，所有的线程操作都需要用户程序自己处理。 线程的创建、切换和调度都是需要考虑的问题，而且由于操作系统只把处理器资源分配到进程，那诸如“阻塞如何处理”、“多处理器系统中如何将线程映射到其他处理器上”这类问题解决起来将会异常困难，甚至不可能完成。Java、Ruby等语言都曾经使用过用户线程，最终又都放弃使用它。
3.1.3 使用用户线程加轻量级进程混合实现
将内核线程与用户线程一起使用的实现方式。在这种混合实现下，既存在用户线程，也存在轻量级进程。 用户线程还是完全建立在用户空间中，因此用户线程的创建、切换、析构等操作依然廉价，并且可以支持大规模的用户线程并发。而操作系统提供支持的轻量级进程则作为用户线程和内核线程之间的桥梁，这样可以使用内核提供的线程调度功能及处理器映射，并且用户线程的系统调用要通过轻量级线程来完成，大大降低了整个进程被完全阻塞的风险。
在这种混合模式中，用户线程与轻量级进程的数量比是不定的，即为N：M的关系。
3.1.4 Java线程的实现
目前的JDK版本中，操作系统支持怎样的线程模型取决于Java虚拟机的线程是怎样映射。线程模型只对线程的并发规模和操作成本产生影响，对Java程序的编码和运行过程来说，这些差异都是透明的。
对于Sun JDK来说，它的Windows和Linux版都是一对一的线程模型实现的，一条Java线程就映射到一条轻量级进程之中。
3.2 Java线程调度
线程调度是指系统为线程分配处理器使用权的过程，主要的调度方式有两种：协同式线程调度（Cooperative Threads-Scheduling）和抢占式线程调度（Preemptive ThreadsScheduling）。
协同式调度:
线程的执行时间由线程本身来控制，线程把自己的工作执行完了之后，要主动通知系统切换到另外一个线程上。
优点：实现简单，而且由于线程要把自己的事情干完后才会进行线程切换，切换操作对线程自己是可知的，所以没有什么线程同步的问题。
缺点：线程执行时间不可控制，甚至如果一个线程编写有问题，一直不告知系统进行线程切换，那么程序就会一直阻塞在那里。
抢占式调度:
线程将由系统来分配执行时间，线程的切换不由线程本身来决定（在Java中，Thread.yield（）可以让出执行时间，但是要获取执行时间的话，线程本身是没有什么办法的）。
在这种实现线程调度的方式下，线程的执行时间是系统可控的，也不会有一个线程导致整个进程阻塞的问题。Java使用的线程调度方式就是抢占式调度。
Java语言一共设置了10个级别的线程优先级（Thread.MIN_PRIORITY至Thread.MAX_PRIORITY），在两个线程同时处于Ready状态时，优先级越高的线程越容易被系统选择执行。Java的线程是通过映射到系统的原生线程上来实现的，所以线程调度最终还是取决于操作系统，即系统线程优先级跟Java线程的优先级一般对不上。
3.3 状态转换
该节内容转自：线程状态
线程共包括以下5种状态。
1. 新建状态(New) : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4. 阻塞状态(Blocked) : 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
(1) 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
(2) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
(3) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。5. 死亡状态(Dead) : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
这5种状态涉及到的内容包括Object类, Thread和synchronized关键字。
1、Object类，定义了wait(), notify(), notifyAll()等休眠/唤醒函数。
2、Thread类，定义了一些列的线程操作函数。例如，sleep()休眠函数, interrupt()中断函数, getName()获取线程名称等。
3、synchronized，是关键字；它区分为synchronized代码块和synchronized方法。synchronized的作用是让线程获取对象的同步锁。
4 总结
本文首先介绍了：
1、Java内存模型的结构及操作；
2、原子性、可见性、有序性在Java内存模型中的体现；
3、先行发生原则的规则及使用；
4、线程在Java语言中是如何实现的。
上一篇：晚期（运行期）优化：https://blog.csdn.net/pcwl1206/article/details/84642835