java并发基础概念扫盲

1.计算机指令的执行

 

计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。

由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内 存写入数据的过程跟CPU 执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和主存的交互来进行，会大大降低指令执 行的速度。因此在CPU里面就有了高速缓存。也就 是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中， 那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据， 当运算结束之后，再将高速缓存中的数据刷新到主存当中

如：i = i + 1;

当线程执行这个语句时，会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入 高速缓存，最后将高速缓 存中i最新的值刷新到主存当中。

 

2.指令重排序（Instruction Reorder）

下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，编译器和cpu都可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同 代码中的顺序一致(happens-before原则)，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。但是要注意，指令重排序不会影响单个线程的执行，但是会 影响到线程并发执行的正确性。

 

happens-before原则：

Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果 两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。

具体介绍下happens-before原则（先行发生原则）：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作

（看起来是前面的操作先发生）

锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作

（对一个对象的操作必须先解锁才能加锁）

volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作

传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C

线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作

线程中断规则：对线程interrupt()

方法的调用先行发生于被中断线程的代码检测到中断事件的发生

线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行

对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始

 

3.原子性、可见性、顺序性

原子性：即操作是原子的，不可分割的

可见性：线程之间对于变量的更改是可见的，一个线程改变一个共享变量，其他的线程会立即看到改变的值

顺序性：代码的执行是要遵循一定顺序的，这个顺序并不是代码书写的顺序，而是编译器和cpu进行重新排序后的顺序

 

4.计算机内存模型

由于内存的速度要远远小于CPU的速度，所以操作系统在内存和CPU之间加了三层缓存，其中L3是所有CPU共享的缓存，L2和L1是CPU私有的缓存。

当程序在运行过程中，会将运算需要的数据从主存（就是图中的内存）复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。

但是这也引入了缓存的一致性问题，每个cpu只执行自己高速缓存中的数据，但是如果当一个cpu将数据做了写操作，但是另一个cpu并不知道数据已经改变，还是读取高速缓存中的原有的老数据，就会造成数据紊乱。为了解决脏数据的问题，现在计算机普遍采用了缓存一致性协议或者总线锁机制来解决。

 

所谓总线锁就是将cpu处理过程加锁，对于一个变量，同一时间只能有一个cpu去操作，操作结束之后其他CPU才能接着去操作。

 

所谓缓存一致性协议。最出名的就是Intel 的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

 

 

5.java内存模型

不同的操作系统，对于缓存的一致性问题有不同的处理。这也就表示，我们的代码如果在不同的操作系统上运行，最终的结果可能是不同的， 为了解决这个问题，java 虚拟机提供了一套java内存模型来解决这个问题。

Java虚拟机试图定义一种java内存模型来屏蔽掉各种硬件个操作系统的内存访问差异，以实现让java程序再各种平台下 都能达到一致的内存访问效果。

Java内存模型定义所有的变量都存储在内存中。每条线程还有自己的私有内存，线程的工作内存中保存了被该线程使用到 的变量的内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程间变量值的传递要通过主内存来实现。

 

6.volatile关键字

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

volatile关键字禁止指令重排序有两层意思：

1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

例：

x = 2;        //语句1     //x、y为非volatile变量

y = 0;        //语句2     //flag为volatile变量

flag = true;  //语句3

x = 4;         //语句4

y = -1;       //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语 句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、 语句5是可见的。

volatile原理：

第一：使用volatile关键字会强制将修改的值立即写入主存；

第二：使用volatile关键字的话，当线程1进行修改时，会导致其他线程的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；

第三：由于其他线程的工作内存中缓存变量stop的缓存行无效，所以其他线程再次读取变量stop的值时会去主存读取。

那么在线程1修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得其他线程的工作内存中缓存变量stop的缓存行无效，然后其他线程读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后， 然后去对应的主存读取最新的值。

那么其他线程读取到的就是最新的正确的值。

volatile能否保证原子性?

volatile也无法保证对变量的任何操作都是原子性的，比如自增操作

volatile和synchrosized区别

synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于 synchronized，但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。

 

7.CAS算法

CAS算法的过程是这样：它包含三个参数 CAS（V,E,N）。V表示要更新的变量，E表示预期的值，N表示新值。仅当V值等于E值时，才会 将 V的值设置成N，否则什么 都不做。最后CAS返回当前V的值。CAS算法需要你额外给出一个期望值，也就是你认为现在 变量应该是什 么样子，如果变量不是你想象的那样，那说明已经被别人修改过。你就重新读取，再次尝试修改即可。