c++ volatile

就是每次都要到内存上读取数据，不能直接用寄存器的数据（第一次直接取自内存而后放在寄存器，第二次编译器就会优化成使用寄存器的值）

并不解决多线程的事

https://liam.page/2018/01/18/volatile-in-C-and-Cpp/

被 volatile 修饰的变量，在对其进行读写操做时，会引起一些可观测的反作用。而这些可观测的反作用，是由程序以外的因素决定的。

 

所以咱们讲，在 C/C++ 中，对 volatile 对象的访问，有编译器优化上的反作用：

• 不容许被优化消失（optimized out）；
• 于序列上在另外一个对 volatile 对象的访问以前。

这里说起的「不容许被优化」表示对 volatile 变量的访问，编译器不能作任何假设和推理，都必须循序渐进地与「内存」进行交互。所以，上述例中「复用寄存器中的值」就是不容许的。

 

• volatile 不能解决多线程中的问题。
• 按照 Hans Boehm & Nick Maclaren 的总结，volatile 只在三种场合下是合适的。
  • 和信号处理（signal handler）相关的场合；
  • 和内存映射硬件（memory mapped hardware）相关的场合；
  • 和非本地跳转（setjmp 和 longjmp）相关的场合。

https://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777432.html

 1. 为何用volatile?

    C/C++ 中的 volatile 关键字和 const 对应，用来修饰变量，一般用于创建语言级别的 memory barrier。这是 BS 在 "The C++ Programming Language" 对 volatile 修饰词的说明：

A volatile specifier is a hint to a compiler that an object may change its value in ways not specified by the language so that aggressive optimizations must be avoided.

      volatile 关键字是一种类型修饰符，用它声明的类型变量表示能够被某些编译器未知的因素更改，好比：操做系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就再也不进行优化，从而能够提供对特殊地址的稳定访问。声明时语法：int volatile vInt; 当要求使用 volatile 声明的变量的值的时候，系统老是从新从它所在的内存读取数据，即便它前面的指令刚刚从该处读取过数据。并且读取的数据马上被保存。例如：

1	volatile int i=10;
2	int a = i;
3	...
4	// 其余代码，并未明确告诉编译器，对 i 进行过操做
5	int b = i;

    volatile 指出 i 是随时可能发生变化的，每次使用它的时候必须从 i的地址中读取，于是编译器生成的汇编代码会从新从i的地址读取数据放在 b 中。而优化作法是，因为编译器发现两次从 i读数据的代码之间的代码没有对 i 进行过操做，它会自动把上次读的数据放在 b 中。而不是从新从 i 里面读。这样以来，若是 i是一个寄存器变量或者表示一个端口数据就容易出错，因此说 volatile 能够保证对特殊地址的稳定访问。注意，在 VC 6 中，通常调试模式没有进行代码优化，因此这个关键字的做用看不出来。下面经过插入汇编代码，测试有无 volatile 关键字，对程序最终代码的影响：

输入下面的代码：

01	#include <stdio.h>
02	 
03	void main()
04	{
05	    int i = 10;
06	    int a = i;
07	 
08	    printf("i = %d", a);
09	 
10	    // 下面汇编语句的做用就是改变内存中 i 的值
11	    // 可是又不让编译器知道
12	    __asm {
13	        mov dword ptr [ebp-4], 20h
14	    }
15	 
16	    int b = i;
17	    printf("i = %d", b);
18

    而后，在 Debug 版本模式运行程序，输出结果以下：

i = 10
i = 32

    而后，在 Release 版本模式运行程序，输出结果以下：

i = 10
i = 10

    输出的结果明显代表，Release 模式下，编译器对代码进行了优化，第二次没有输出正确的 i 值。下面，咱们把 i 的声明加上 volatile 关键字，看看有什么变化：

01	#include <stdio.h>
02	 
03	void main()
04	{
05	    volatile int i = 10;
06	    int a = i;
07	 
08	    printf("i = %d", a);
09	    __asm {
10	        mov dword ptr [ebp-4], 20h
11	    }
12	 
13	    int b = i;
14	    printf("i = %d", b);
15

    分别在 Debug 和 Release 版本运行程序，输出都是：

i = 10
i = 32

    这说明这个 volatile 关键字发挥了它的做用。其实不仅是“内嵌汇编操纵栈”这种方式属于编译没法识别的变量改变，另外更多的多是多线程并发访问共享变量时，一个线程改变了变量的值，怎样让改变后的值对其它线程 visible。通常说来，volatile用在以下的几个地方： 
1) 中断服务程序中修改的供其它程序检测的变量须要加volatile； 
2) 多任务环境下各任务间共享的标志应该加volatile； 
3) 存储器映射的硬件寄存器一般也要加volatile说明，由于每次对它的读写均可能由不一样意义；

2.volatile 指针

    和 const 修饰词相似，const 有常量指针和指针常量的说法，volatile 也有相应的概念：

• 修饰由指针指向的对象、数据是 const 或 volatile 的：

  1	const char* cpch;
  2	volatile char* vpch;

  注意：对于 VC，这个特性实如今 VC 8 以后才是安全的。

• 指针自身的值——一个表明地址的整数变量，是 const 或 volatile 的：

  1	char* const pchc;
  2	char* volatile pchv;

    注意：(1) 能够把一个非volatile int赋给volatile int，可是不能把非volatile对象赋给一个volatile对象。

　　        (2) 除了基本类型外，对用户定义类型也能够用volatile类型进行修饰。
              (3) C++中一个有volatile标识符的类只能访问它接口的子集，一个由类的实现者控制的子集。用户只能用const_cast来得到对类型接口的彻底访问。此外，volatile向const同样会从类传递到它的成员。

3. 多线程下的volatile   

    有些变量是用volatile关键字声明的。当两个线程都要用到某一个变量且该变量的值会被改变时，应该用volatile声明，该关键字的做用是防止优化编译器把变量从内存装入CPU寄存器中。若是变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会形成程序的错误执行。volatile的意思是让编译器每次操做该变量时必定要从内存中真正取出，而不是使用已经存在寄存器中的值，以下： 

  volatile  BOOL  bStop  =  FALSE;     (1) 在一个线程中：    while(  !bStop  )  {  ...  }    bStop  =  FALSE;    return;       (2) 在另一个线程中，要终止上面的线程循环：    bStop  =  TRUE;    while(  bStop  );  //等待上面的线程终止，若是bStop不使用volatile申明，那么这个循环将是一个死循环，由于bStop已经读取到了寄存器中，寄存器中bStop的值永远不会变成FALSE，加上volatile，程序在执行时，每次均从内存中读出bStop的值，就不会死循环了。    这个关键字是用来设定某个对象的存储位置在内存中，而不是寄存器中。由于通常的对象编译器可能会将其的拷贝放在寄存器中用以加快指令的执行速度，例以下段代码中：    ...    int  nMyCounter  =  0;    for(;  nMyCounter<100;nMyCounter++)    {    ...    }    ...     在此段代码中，nMyCounter的拷贝可能存放到某个寄存器中（循环中，对nMyCounter的测试及操做老是对此寄存器中的值进行），可是另外又有段代码执行了这样的操做：nMyCounter  -=  1;这个操做中，对nMyCounter的改变是对内存中的nMyCounter进行操做，因而出现了这样一个现象：nMyCounter的改变不一样步。