编译器重排序和处理器重排序

① 什么是指令重排

什么是指令重排序？
有两个层面：
**在虚拟机层面，**为了尽可能减少内存操作速度远慢于CPU运行速度所带来的CPU空置的影响，虚拟机会按照自己的一些规则(这规则后面再叙述)将程序编写顺序打乱——即写在后面的代码在时间顺序上可能会先执行，而写在前面的代码会后执行——以尽可能充分地利用CPU。拿上面的例子来说：假如不是a=1的操作，而是a=new byte1024*1024，那么它会运行地很慢，此时CPU是等待其执行结束呢，还是先执行下面那句flag=true呢？显然，先执行flag=true可以提前使用CPU，加快整体效率，当然这样的前提是不会产生错误(什么样的错误后面再说)。虽然这里有两种情况：后面的代码先于前面的代码开始执行；前面的代码先开始执行，但当效率较慢的时候，后面的代码开始执行并先于前面的代码执行结束。不管谁先开始，总之后面的代码在一些情况下存在先结束的可能。
**在硬件层面，**CPU会将接收到的一批指令按照其规则重排序，同样是基于CPU速度比缓存速度快的原因，和上一点的目的类似，只是硬件处理的话，每次只能在接收到的有限指令范围内重排序，而虚拟机可以在更大层面、更多指令范围内重排序。硬件的重排序机制参见《从JVM并发看CPU内存指令重排序(Memory Reordering)》
java提供了两个关键字volatile和synchronized来保证多线程之间操作的有序性,volatile关键字本身通过加入内存屏障来禁止指令的重排序，而synchronized关键字通过一个变量在同一时间只允许有一个线程对其进行加锁的规则来实现。
在单线程程序中，不会发生“指令重排”和“工作内存和主内存同步延迟”现象，只在多线程程序中出现。
1）编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
2）指令级并行的重排序。现代处理器采用了指令级并行技术（Instruction-LevelParallelism，ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
3）内存系统的重排序。由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行

② 请教处理器cache与指令重排序问题

存储器：具有记忆功能的物理器件，用于存储信息。存储器分为内存和外存 ①内存是半导体存储器(主存）： 它分为只读存储器(ROM)和随机存储器(RAM)和高速缓冲存储器（Cache)； ROM:只能读，不能用普通方法写入，通常由厂家生产时写入，写入后数据不容易丢失，也可以用特殊方法（如紫外线擦除（EPROM)或电擦除(EEPROM_)存储器)； RAM:可读可写，断电后内容全部丢失； Cache:因为CPU读写RAM的时间需要等待，为了减少等待时间，在RAM和CPU间需要设置高速缓存Cache,断电后其内容丢失。 ②外存：磁性存储器——软盘和硬盘；光电存储器——光盘，它们可以作为永久存器； ③存储器的两个重要技术指标：存取速度和存储容量。内存的存取速度最快(与CPU速 度相匹配)，软盘存取速度最慢。存储容量是指存储的信息量，它用字节(Byte)作为基本单位， 1字节用8位二进制数表示，1KB=1024B，1MB=1024KB，lGB=1024MB

③ java指令重排序,happens-before的问题

不会的。
java代码肯定是执行t.i = 1这个后，
再执行new Thread(t).start();这个
所以不会出现你说的情况

④ 指令重排序会破坏happens-before原则吗

线程A:
readConfig(); //读取配置
init=true;

线程B:
while(init){
useConfig(); //使用配置
}

由于线程A可能会发生指令重排序，所以线程B使用的配置可能尚未加载，所以使用volatile解决此问题。

比如说，在readConfig();里有N多的指令要执行
指令
a
b
c
d
init=true;

如果abcd和init变量都没有关系，就是不存在happens-before关系的话，若果被重排，比如说可能变成
a
b
init=true;
c
d

此时其实c，d还没有执行 但是b线程里init=true;已经成立了。。。所以就执行 useConfig(); 了 然后会出错

⑤ 几种常见的数据依赖

如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据依赖性。数据依赖分为下列3种类型，如表3-4所示。



上面3种情况，只要重排序两个操作的执行顺序，程序的执行结果就会被改变。

前面提到过，编译器和处理器可能会对操作做重排序。编译器和处理器在重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。

这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作，不同处理器之间和不同线程之间的数据依赖性不被编译器和处理器考虑。

注：本文源自《Java并发编程的艺术》一文。

⑥ java中volatile修饰的变量有什么特征

volatile是一个类型修饰符，它是被设计用来修饰被不同线程访问和修改的变量，可以被异步的线程所修改。
final必须对它赋予初值并且不能修改它。
对比就知道两个修饰符是冲突的，放一起是要干什么呢？

⑦ SET I1=100 指令的含义是将100的值赋给()

摘要 重排序后， a 的两次操作被放到一起，指令执行情况变为 Load a、Set to 100、Set to 110、 Store a。下面和 b 相关的指令不变，仍对应 Load b、 Set to 5、Store b。

⑧ 线程安全的关键字

Java语言中关键字 volatile 被称作轻量级的 synchronized，与synchronized相比，volatile编码相对简单且运行的时的开销较少，但能够正确合理的应用好 volatile 并不是那么的容易，因为它比使用锁更容易出错，接下来本文主要介绍 volatile 的使用准则，以及使用过程中需注意的地方。
为何使用volatile？
（1）简易性：在某些需要同步的场景下使用volatile变量要比使用锁更加简单
（2）性能：在某些情况下使用volatile同步机制的性能要优于锁
（3）volatile操作不会像锁一样容易造成阻塞
volatile特性
（1）volatile 变量具有 synchronized 的可见性特性，及如果一个字段被声明为volatile，java线程内存模型确保所有的线程看到这个变量的值是一致的
（2）禁止进行指令重排序
（3）不保证原子性
注：① 重排序：重排序通常是编译器或运行时环境为了优化程序性能而采取的对指令进行重新排序执行的一种手段
② 原子性：不可中断的一个或一系列操作
③ 可见性：锁提供了两种主要特性：互斥和可见性，互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的。
volatile的实现原理
如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，该Lock指令会使这个变量所在缓存行的数据回写到系统内存，根据缓存一致性协议，每个处理器都会通过嗅探在总线上传输的数据来检查自己缓存的值是否已过期，当处理器发现自己的缓存行对应的地址被修改，就会将当前处理器的缓存行设置成无效状态，在下次访问相同内存地址时，强制执行缓存行填充。

⑨ java中虚拟机的内存到底分为几类呢，网上说法挺多，能不能给个专业的

Java内存模型
主内存与工作内存
Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样底层细节。此处的变量与Java编程时所说的变量不一样，指包括了实例字段、静态字段和构成数组对象的元素，但是不包括局部变量与方法参数，后者是线程私有的，不会被共享。
Java内存模型中规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存（可以与前面将的处理器的高速缓存类比），线程的工作内存中保存了该线程使用到的变量到主内存副本拷贝，线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来完成，线程、主内存和工作内存的交互关系如下图所示

这里的主内存、工作内存与Java内存区域的Java堆、栈、方法区不是同一层次内存划分。
内存间交互操作
关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：
· lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
· unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
· read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
· load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
· use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
· assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
· store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
· write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。也就是read和load之间，store和write之间是可以插入其他指令的，如对主内存中的变量a、b进行访问时，可能的顺序是read a，read b，load b， load a。Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：
· 不允许read和load、store和write操作之一单独出现
· 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
· 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
· 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
· 一个变量在同一时刻只允许一条线程对其进行lock操作，lock和unlock必须成对出现
· 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
· 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
· 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。
重排序
在执行程序时为了提高性能，编译器和处理器经常会对指令进行重排序。重排序分成三种类型：

编译器优化的重排序。编译器在不改变单线程程序语义放入前提下，可以重新安排语句的执行顺序。

指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。

内存系统的重排序。由于处理器使用缓存和读写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。
从Java源代码到最终实际执行的指令序列，会经过下面三种重排序：

为了保证内存的可见性，Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。Java内存模型把内存屏障分为LoadLoad、LoadStore、StoreLoad和StoreStore四种：

同步机制
介绍volatile、synchronized和final
原子性、可见性与有序性
Java内存模型JMM解决了可见性和有序性的问题，而锁解决了原子性的问题。

可见性
指的是一个线程对变量的写操作对其他线程后续的读操作可见。由于现代CPU都有多级缓存，CPU的操作都是基于高速缓存的，而线程通信是基于内存的，这中间有一个Gap,可见性的关键还是在对变量的写操作之后能够在某个时间点显示地写回到主内存，这样其他线程就能从主内存中看到最新的写的值。volatile，synchronized(隐式锁), 显式锁，原子变量这些同步手段都可以保证可见性。
可见性底层的实现是通过加内存屏障实现的：
1. 写变量后加写屏障，保证CPU写缓冲区的值强制刷新回主内存
2. 读变量之前加读屏障，使缓存失效，从而强制从主内存读取变量最新值
写volatile变量 = 进入锁
读volatile变量 = 释放锁

有序性
指的是数据不相关的变量在并发的情况下，实际执行的结果和单线程的执行结果是一样的，不会因为重排序的问题导致结果不可预知。volatile, final, synchronized，显式锁都可以保证有序性。
有序性的语意有几层，
1. 最常见的就是保证多线程执行的串行顺序
2. 防止重排序引起的问题
3. 程序执行的先后顺序，比如JMM定义的一些Happens-before规则

重排序
的问题是一个单独的主题，常见的重排序有3个层面:
1. 编译级别的重排序，比如编译器的优化
2. 指令级重排序，比如CPU指令执行的重排序
3. 内存系统的重排序，比如缓存和读写缓冲区导致的重排序

原子性
是指某个(些)操作在语意上是原子的。比如读操作，写操作，CAS(compareand set)操作在机器指令级别是原子的，又比如一些复合操作在语义上也是原子的，如先检查后操作if(xxx== null){}
有个专有名词竞态条件来描述原子性的问题。
竞态条件(racing condition)是指某个操作由于不同的执行时序而出现不同的结果，比如先检查后操作。
volatile变量只保证了可见性，不保证原子性，比如a++这种操作在编译后实际是多条语句，比如先读a的值，再加1操作，再写操作，执行了3个原子操作，如果并发情况下，另外一个线程很有可能读到了中间状态，从而导致程序语意上的不正确。所以a++实际是一个复合操作。
加锁可以保证复合语句的原子性，sychronized可以保证多条语句在synchronized块中语意上是原子的。
显式锁保证临界区的原子性。
原子变量也封装了对变量的原子操作。
非阻塞容器也提供了原子操作的接口，比如putIfAbsent。

⑩ C++编译器（Dev-C）是否会自动内联函数 对于什么样的函数即使标记inline也会拒绝内联

G++编译器是否会自动进行内联函数？

G++编译器是很先进的，编译的时候如果开启优化，G++会代码进行各种优化，如：对合适的函数进行内联（即便是没有添加inline关键字），对某些函数直接对其进行求值，除此之外G++编译器还可以对代码进行重排序 等等。编译器比你更了解硬件，所以只要允许它优化，他会尽量进行优化。你使用的Dev C++集成开发环境使用的c++编译器就是G++。

什么样的函数即使标记inline也无法内联？

比如函数体太大、太复杂的话（比如包含多重循环、包含递归调用），对其进行内联得不偿失，这时编译器就会忽略inline关键字，VC++编译器提供了强制内联函数的关键字，除非你非常了解硬件，不然最好让编译器来处。编译不对那些函数进行内联要看具体的编译器实现了。

inline关键字的有哪些作用？

inline关键字可以提示编译器对某个函数进行内联，并且强制函数使用内部链接。比如说你在头文件定义了某个函数，为了防止多重定义，你可以添加inline关键字来防止多重定义错误。

如果对硬件不是很了解，底层的代码优化还是留给编译器来处理。

看看下面的几个编译器优化函数的例子：

1.编译器直接对函数求值：

解释一下：

第一条和第二天指令分别将b和a的地址加载到寄存器rdx和rcx中

第三条指令将b的值加载到eax寄存器中

第四条指令将34存入b中

第五条指令将eax的值加1（eax保存了之前b的值）

第六条指令将eax的值存入a中

可以看出编译器将函数的两条语句换了位置，这种优化主要是优化代码的执行速度，有的CPU内存读写操作的的开销不一样，所以重新排序一下某些代码能够提高程序执行速度。