精华内容
下载资源
问答
  • C++volatile关键字作用

    千次阅读 2019-04-29 23:59:22
    volatile关键字是防止在共享的空间发生读取的错误。只保证其可见性,不保证原子性;使用volatile指每次从内存中读取数据,而不是从编译器优化后的缓存中读取数据,简单来讲就是防止编译器优化。 在单任务环境中,...

    volatile的作用

    volatile关键字是防止在共享的空间发生读取的错误。只保证其可见性,不保证原子性;使用volatile指每次从内存中读取数据,而不是从编译器优化后的缓存中读取数据,简单来讲就是防止编译器优化。

    在单任务环境中,如果在两次读取变量之间不改变变量的值,编译器就会发生优化,会将RAM中的值赋值到寄存器中;由于访问寄存器的效率要高于RAM,所以在需要读取变量时,直接寄存器中获取变量的值,而不是从RAM中。

    在多任务环境中,虽然在两次读取变量之间不改变变量的值,在一些情况下变量的值还是会发生改变,比如在发生中断程序或者有其他的线程。这时候如果编译器优化,依旧从寄存器中获取变量的值,修改的值就得不到及时的相应(在RAM还未将新的值赋值给寄存器,就已经获取到寄存器的值)。

    #include <iostream>
    using namespace std;
    
    int main(int argc,char* argv[])
    {
        int i=10;
        int a=i;
        cout<<a<<endl;
        _asm
        {
            mov dword ptr [ebp-4],80
        }
        int b=i;
        cout<<b<<endl;
    }

    输出结果:

    10
    10 

    注:必须在Release版本在,在Release才会对代码进行优化 

    要想防止编译器优化,就需要在声明变量i时前加volatile关键字,就会输出 10 80;加关键字后,就在RAM中读取变量的值,而不是直接在寄存器中取值

    展开全文
  • 详解C/C++volatile关键字

    万次阅读 多人点赞 2019-06-19 17:11:48
    如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。下面举例说明。在DSP开发中,经常需要等待某个事件的触发,所以经常会写...

    一、volatile介绍

    volatile提醒编译器它后面所定义的变量随时都有可能改变,因此编译后的程序每次需要存储或读取这个变量的时候,都会直接从变量地址中读取数据。如果没有volatile关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值,如果这个变量由别的程序更新了的话,将出现不一致的现象。下面举例说明。在DSP开发中,经常需要等待某个事件的触发,所以经常会写出这样的程序:

    这段程序等待内存变量flag的值变为1(怀疑此处是0,有点疑问,)之后才运行do2()。变量flag的值由别的程序更改,这个程序可能是某个硬件中断服务程序。例如:如果某个按钮按下的话,就会对DSP产生中断,在按键中断程序中修改flag为1,这样上面的程序就能够得以继续运行。但是,编译器并不知道flag的值会被别的程序修改,因此在它进行优化的时候,可能会把flag的值先读入某个寄存器,然后等待那个寄存器变为1。如果不幸进行了这样的优化,那么while循环就变成了死循环,因为寄存器的内容不可能被中断服务程序修改。为了让程序每次都读取真正flag变量的值,就需要定义为如下形式:
    在这里插入图片描述
    需要注意的是,没有volatile也可能能正常运行,但是可能修改了编译器的优化级别之后就又不能正常运行了。因此经常会出现debug版本正常,但是release版本却不能正常的问题。所以为了安全起见,只要是等待别的程序修改某个变量的话,就加上volatile关键字。

    volatile的本意是“易变的”,由于访问寄存器的速度要快过RAM,所以编译器一般都会作减少存取外部RAM的优化。比如:

    程序的本意是希望ISR_2中断产生时,在main当中调用do_something函数,但是,由于编译器判断在main函数里面没有修改过i,因此可能只执行一次对从i到某寄存器的读操作,然后每次if判断都只使用这个寄存器里面的“i副本”,导致do_something永远也不会被调用。如果变量加上volatile修饰,则编译器保证对此变量的读写操作都不会被优化(肯定执行)。此例中i也应该如此说明。
    一般说来,volatile用在如下的几个地方:
    1、中断服务程序中修改的供其它程序检测的变量需要加volatile;
    2、多任务环境下各任务间共享的标志应该加volatile;
    3、存储器映射的硬件寄存器通常也要加volatile说明,因为每次对它的读写都可能由不同意义;
    另外,以上这几种情况经常还要同时考虑数据的完整性(相互关联的几个标志读了一半被打断了重写),在1中可以通过关中断来实现,2中可以禁止任务调度,3中则只能依靠硬件的良好设计了。

    二、volatile 的含义

    volatile总是与优化有关,编译器有一种技术叫做数据流分析,分析程序中的变量在哪里赋值、在哪里使用、在哪里失效,分析结果可以用于常量合并,常量传播等优化,进一步可以死代码消除。但有时这些优化不是程序所需要的,这时可以用volatile关键字禁止做这些优化,volatile的字面含义是易变的,它有下面的作用:

    1 不会在两个操作之间把volatile变量缓存在寄存器中。在多任务、中断、甚至setjmp环境下,变量可能被其他的程序改变,编译器自己无法知道,volatile就是告诉编译器这种情况。

    2 不做常量合并、常量传播等优化,所以像下面的代码:
    在这里插入图片描述
    if的条件不会当作无条件真。

    3 对volatile变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到,编译器常常可以省略那个赋值操作,然而对Memory Mapped IO的处理是不能这样优化的。
    前面有人说volatile可以保证对内存操作的原子性,这种说法不大准确,其一,x86需要LOCK前缀才能在SMP下保证原子性,其二,RISC根本不能对内存直接运算,要保证原子性得用别的方法,如atomic_inc。
    对于jiffies,它已经声明为volatile变量,我认为直接用jiffies++就可以了,没必要用那种复杂的形式,因为那样也不能保证原子性。
    你可能不知道在Pentium及后续CPU中,下面两组指令作用相同,但一条指令反而不如三条指令快。
    在这里插入图片描述

    三、编译器优化 → C关键字volatile → memory破坏描述符

    memory比较特殊,可能是内嵌汇编中最难懂部分。为解释清楚它,先介绍一下编译器的优化知识,再看C关键字volatile。最后去看该描述符。

    1、编译器优化介绍

    内存访问速度远不及CPU处理速度,为提高机器整体性能,在硬件上引入硬件高速缓存Cache,加速对内存的访问。另外在现代CPU中指令的执行并不一定严格按照顺序执行,没有相关性的指令可以乱序执行,以充分利用CPU的指令流水线,提高执行速度。以上是硬件级别的优化。再看软件一级的优化:一种是在编写代码时由程序员优化,另一种是由编译器进行优化。编译器优化常用的方法有:将内存变量缓存到寄存器;调整指令顺序充分利用CPU指令流水线,常见的是重新排序读写指令。对常规内存进行优化的时候,这些优化是透明的,而且效率很好。由编译器优化或者硬件重新排序引起的问题的解决办法是在从硬件(或者其他处理器)的角度看必须以特定顺序执行的操作之间设置内存屏障(memory barrier),linux 提供了一个宏解决编译器的执行顺序问题。
    在这里插入图片描述
    这个函数通知编译器插入一个内存屏障,但对硬件无效,编译后的代码会把当前CPU寄存器中的所有修改过的数值存入内存,需要这些数据的时候再重新从内存中读出。

    2、C语言关键字volatile

    C语言关键字volatile(注意它是用来修饰变量而不是上面介绍的volatile)表明某个变量的值可能在外部被改变,因此对这些变量的存取不能缓存到寄存器,每次使用时需要重新存取。该关键字在多线程环境下经常使用,因为在编写多线程的程序时,同一个变量可能被多个线程修改,而程序通过该变量同步各个线程,例如:
    在这里插入图片描述
    该线程启动时将intSignal置为2,然后循环等待直到intSignal为1时退出。显然intSignal的值必须在外部被改变,否则该线程不会退出。但是实际运行的时候该线程却不会退出,即使在外部将它的值改为1,看一下对应的伪汇编代码就明白了:
    在这里插入图片描述
    对于C编译器来说,它并不知道这个值会被其他线程修改。自然就把它cache在寄存器里面。记住,C 编译器是没有线程概念的!这时候就需要用到volatile。volatile 的本意是指:这个值可能会在当前线程外部被改变。也就是说,我们要在threadFunc中的intSignal前面加上volatile关键字,这时候,编译器知道该变量的值会在外部改变,因此每次访问该变量时会重新读取,所作的循环变为如下面伪码所示:
    在这里插入图片描述
    3、Memory

    有了上面的知识就不难理解Memory修改描述符了,Memory描述符告知GCC:
    1)不要将该段内嵌汇编指令与前面的指令重新排序;也就是在执行内嵌汇编代码之前,它前面的指令都执行完毕。
    2)不要将变量缓存到寄存器,因为这段代码可能会用到内存变量,而这些内存变量会以不可预知的方式发生改变,因此GCC插入必要的代码先将缓存到寄存器的变量值写回内存,如果后面又访问这些变量,需要重新访问内存。
    如果汇编指令修改了内存,但是GCC 本身却察觉不到,因为在输出部分没有描述,此时就需要在修改描述部分增加“memory”,告诉GCC 内存已经被修改,GCC 得知这个信息后,就会在这段指令之前,插入必要的指令将前面因为优化Cache 到寄存器中的变量值先写回内存,如果以后又要使用这些变量再重新读取。
    使用“volatile”也可以达到这个目的,但是我们在每个变量前增加该关键字,不如使用“memory”方便。

    展开全文
  • volatile关键字及其作用(举例说明)

    千次阅读 2021-01-31 22:49:33
    volatile关键字及其作用 一、多线程并发编程中主要围绕着三个特性实现。 可见性 可见性是指当多个线程访问同一个共享变量时,一个线程修改了这个变量的值,其他线程能够立即看到修改后的值。 原子性 原子性指的一个...

    volatile关键字及其作用

    一、多线程并发编程中主要围绕着三个特性实现。

    可见性
    可见性是指当多个线程访问同一个共享变量时,一个线程修改了这个变量的值,其他线程能够立即看到修改后的值。

    原子性
    原子性指的一个操作或一组操作要么全部执行,要么全部不执行。

    有序性
    有序性是指程序执行的顺序按照代码的先后顺序执行。

    二、volatile 除了解决共享变量的可见性,还有别的作用吗?

    volatile 除了让共享变量具有可见性,还具有有序性(禁止指令重排序)。

    三、举几个实际volatile 实际项目中的例子?

    1.状态标志
    比如我们工程中经常用一个变量标识程序是否启动、初始化完成、是否停止等,如下:在这里插入图片描述volatile 很适合只有一个线程修改,其他线程读取的情况。volatile 变量被修改之后,对其他线程立即可见。

    如果不加volatile 修饰,会有什么后果?
    比如这是一个带前端交互的系统,有A、 B二个线程,用户点了停止应用按钮,A 线程调用shutdown() 方法,让变量shutdown 从false 变成 true,但是因为没有使用volatile 修饰, B 线程可能感知不到shutdown 的变化,而继续执行 doWork 内的循环,这样违背了程序的意愿:当shutdown 变量为true 时,代表应用该停下了,doWork函数应该跳出循环,不再执行。

    2.懒汉式单例模式
    在这里插入图片描述
    使用volatile 修饰保证 singleton 的实例化能够对所有线程立即可见。

    1.为什么使用volatile 修饰了singleton 引用还用synchronized 锁?
    volatile 只保证了共享变量 singleton 的可见性,但是 singleton = new Singleton(); 这个操作不是原子的,可以分为三步:

    步骤1:在堆内存申请一块内存空间;

    步骤2:初始化申请好的内存空间;

    步骤3:将内存空间的地址赋值给 singleton;

    所以singleton = new Singleton(); 是一个由三步操作组成的复合操作,多线程环境下A 线程执行了第一步、第二步之后发生线程切换,B 线程开始执行第一步、第二步、第三步(因为A 线程singleton 是还没有赋值的),所以为了保障这三个步骤不可中断,可以使用synchronized 在这段代码块上加锁。

    2.第一次检查singleton 为空后为什么内部还需要进行第二次检查?
    A 线程进行判空检查之后开始执行synchronized代码块时发生线程切换(线程切换可能发生在任何时候),B 线程也进行判空检查,B线程检查 singleton == null 结果为true,也开始执行synchronized代码块,虽然synchronized 会让二个线程串行执行,如果synchronized代码块内部不进行二次判空检查,singleton 可能会初始化二次。

    3.volatile 除了内存可见性,还有别的作用吗?
    volatile 修饰的变量除了可见性,还能防止指令重排序。

    指令重排序 是编译器和处理器为了优化程序执行的性能而对指令序列进行重排的一种手段。现象就是CPU 执行指令的顺序可能和程序代码的顺序不一致,例如 a = 1; b = 2; 可能 CPU 先执行b=2; 后执行a=1;

    singleton = new Singleton(); 由三步操作组合而成,如果不使用volatile 修饰,可能发生指令重排序。步骤3 在步骤2 之前执行,singleton 引用的是还没有被初始化的内存空间,别的线程调用单例的方法就会引发未被初始化的错误。
    指令重排序也遵循一定的规则:

    重排序不会对存在依赖关系的操作进行重排
    在这里插入图片描述
    重排序目的是优化性能,不管怎样重排,单线程下的程序执行结果不会变。
    在这里插入图片描述
    因此volatile 还有禁止指令重排序的作用。

    展开全文
  • 近期看到C++标准中对volatile关键字的定义,发现和java的volatile关键字完全不一样,C++的volatile对并发编程基本没有帮助。网上也看到很多关于volatile的误解,于是决定写这篇文章详细解释一下volatile的作用到底是...

     

    近期看到C++标准中对volatile关键字的定义,发现和java的volatile关键字完全不一样,C++的volatile对并发编程基本没有帮助。网上也看到很多关于volatile的误解,于是决定写这篇文章详细解释一下volatile的作用到底是什么。

    编译器对代码的优化

    在讲volatile关键字之前,先讲一下编译器的优化。

    int main() {
        int i = 0;
        i++;
        cout << "hello world" << endl;
    }

    按照代码,这个程序会在内存中预留int大小的空间,初始化这段内存为0,然后这段内存中的数据加1,最后输出“hello world”到标准输出中。但是根据这段代码编译出来的程序(加-O2选项),不会预留int大小的内存空间,更不会对内存中的数字加1。他只会输出“hello world”到标准输出中。

    其实不难理解,这个是编译器为了优化代码,修改了程序的逻辑。实际上C++标准是允许写出来的代码和实际生成的程序不一致的。虽说优化代码是件好事情,但是也不能让编译器任意修改程序逻辑,不然的话我们没办法写可靠的程序了。所以C++对这种逻辑的改写是有限制的,这个限制就是在编译器修改逻辑后,程序对外界的IO依旧是不变的。怎么理解呢?实际上我们可以把我们写出来的程序看做是一个黑匣子,如果按照相同的顺序输入相同的输入,他就每次都会以同样的顺序给出同样的输出。这里的输入输出包括了标准输入输出、文件系统、网络IO、甚至一些system call等等,所有程序外部的事物都包含在内。所以对于程序使用者来说,只要两个黑匣子的输入输出是完全一致的,那么这两个黑匣子是一致的,所以编译器可以在这个限制下任意改写程序的逻辑。这个规则又叫as-if原则。

    volatile关键字的作用

    不知道有没有注意到,刚刚提到输入输出的时候,并没有提到内存,事实上,程序对自己内存的操作不属于外部的输入输出。这也是为什么在上述例子中,编译器可以去除对i变量的操作。但是这又会出现一个麻烦,有些时候操作系统会把一些硬件映射到内存上,让程序通过对内存的操作来操作这个硬件,比如说把磁盘空间映射到内存中。那么对这部分内存的操作实际上就属于对程序外部的输入输出了。对这部分内存的操作是不能随便修改顺序的,更不能忽略。这个时候volatile就可以派上用场了。按照C++标准,对于glvalue的volatile变量进行操作,与其他输入输出一样,顺序和内容都是不能改变的。这个结果就像是把对volatile的操作看做程序外部的输入输出一样。(glvalue是值类别的一种,简单说就是内存上分配有空间的对象,更详细的请看我的另一篇文章。)

    按照C++标准,这是volatile唯一的功能,但是在一些编译器(如,MSVC)中,volatile还有线程同步的功能,但这就是编译器自己的拓展了,并不能跨平台应用。

    对volatile常见的误解

    实际上“volatile可以在线程间同步”也是比较常见的误解。比如以下的例子:

    class AObject
    {
    public:
        void wait()
        {
            m_flag = false;
            while (!m_flag)
            {
                this_thread::sleep(1000ms);
            }
        }
        void notify()
        {
            m_flag = true;
        }
    
    private:
        volatile bool m_flag;
    };
    
    AObject obj;
    
    ...
    
    // Thread 1
    ...
    obj.wait();
    ...
    
    // Thread 2
    ...
    obj.notify();
    ...

    对volatile有误解的人,或者对并发编程不了解的人可能会觉得这段逻辑没什么问题,可能会认为volatile保证了,wait()对m_flag的读取,notify()对m_flag的写入,所以Thread 1能够正常醒来。实际上并不是这么简单,因为在多核CPU中,每个CPU都有自己的缓存。缓存中存有一部分内存中的数据,CPU要对内存读取与存储的时候都会先去操作缓存,而不会直接对内存进行操作。所以多个CPU“看到”的内存中的数据是不一样的,这个叫做内存可见性问题(memory visibility)。放到例子中就是,Thread 2修改了m_flag对应的内存,但是Thread 1在其他CPU核上运行,所以Thread 1不一定能看到Thread 2对m_flag做的更改。C++11开始,C++标准中有了线程的概念,C++标准规定了什么情况下一个线程一定可以看到另一个线程做的内存的修改。而根据标准,上述例子中的Thread 1可能永远看不到m_flag变成true,更严重的是,Thread 1对m_flag的读取会导致Undefined Behavior。

    从C++标准来说,这段代码是Undefined Behavior,既然是Undefined Behavior的话,是不是也可能正确执行?是的,熟悉MESI的应该会知道,Thread 2的修改导致缓存变脏,Thread 1读取内存会试图获取最新的数据,所以这段代码可以正常执行。那是不是就意味着我们可以放心使用volatile来做线程的同步?不是的,只是在这个例子能够正确执行而已。我们对例子稍作修改,volatile就没那么好使了。

    class AObject
    {
    public:
        void wait()
        {
            m_flag = false;
            while (!m_flag)
            {
                this_thread::sleep(1000ms);
            }
        }
        void notify()
        {
            m_flag = true;
        }
    
    private:
        volatile bool m_flag;
    };
    
    AObject obj;
    bool something = false;
    ... 
    
    // Thread 1 
    ... 
    obj.wait(); 
    assert(something)
    ... 
    
    // Thread 2 
    ... 
    something = true;
    obj.notify();
     ...

    在以上代码中,Thread 1的assert语句可能会失败。就如前文所说,C++编译器在保证as-if原则下可以随意打乱变量赋值的顺序,甚至移除某个变量。所以上述例子中的“something = true"语句可能发生在obj.notify()之后。这样的话,“assert(something)”就会失败了。

    那么我们可不可能把something也变成volatile?如果something是volatile,我们确实能够保证编译出来的程序中的语句顺序和源代码一致,但我们仍然不能保证两个语句是按照源代码中的顺序执行,因为现代CPU往往都有乱序执行的功能。所谓乱序执行,CPU会在保证代码正确执行的基础上,调整指令的顺序,加快程序的运算,更多细节我们不在这里展开。我们如果单看Thread 2线程,something和m_flag这两个变量的读写是没有依赖关系的,而Thread 2线程看不到这两个变量在其他线程上的依赖关系,所以CPU可能会打乱他们的执行顺序,或者同时执行这两个指令。结果就是,在Thread 1中,obj.wait()返回后,something可能仍然是false,assert失败。当然,会不会出现这样的状况,实际上也和具体的CPU有关系。但是我们知道错误的代码可能会引起错误的结果,我们应该避免错误的写法,而这个错误就在于误用了volatile关键字,volatile可以避免优化、强制内存读取的顺序,但是volatile并没有线程同步的语义,C++标准并不能保证它在多线程情况的正确性。

    那么用不了volatile,我们该怎么修改上面的例子?C++11开始有一个很好用的库,那就是atomic类模板,在<atomic>头文件中,多个线程对atomic对象进行访问是安全的,并且提供不同种类的线程同步。不同种类的线程同步非常复杂,要涉及到C++的内存模型与并发编程,我就不在此展开。它默认使用的是最强的同步,所以我们就使用默认的就好。以下为修改后的代码:

    class AObject
    {
    public:
        void wait()
        {
            m_flag = false;
            while (!m_flag)
            {
                this_thread::sleep(1000ms);
            }
        }
        void notify()
        {
            m_flag = true;
        }
    
    private:
        atomic<bool> m_flag;
    };

    只要把“volatile bool”替换为“atomic<bool>”就可以。<atomic>头文件也定义了若干常用的别名,例如“atomic<bool>”就可以替换为“atomic_bool”。atomic模板重载了常用的运算符,所以atomic<bool>使用起来和普通的bool变量差别不大。

     

    转自 https://www.cnblogs.com/zhao-zongsheng/p/9092520.html

    展开全文
  • C++volatile关键字的使用详解

    千次阅读 2019-05-26 16:04:51
    C/C++中的 volatile 关键字 和const对应,用来修饰变量,通常用于建立语言级别的memory barrier。这是BS在“The C++ Programming Language”对volatile修饰词的解释:A volatile specifier is a hint to a compiler...
  • 但有时这些优化不是程序所需要的,这时可以用volatile关键字禁止做这些优化。 二.volatile详解: 1.原理作用: volatile的本意是“易变的” ,因为访问寄存器要比访问内存单元快的多,所以编译器一般都会作减少存取...
  • 介绍Volatile关键字之前我们先了解一下编译器的优化。 高速缓存:处理器读取程序里面的数据时,把一些访问频率比较高的数据,临时存储到寄存器(register)中,当需要取数据时,就会从 register 中取,而不是直接去从...
  • volatile 关键字是一种类型修饰符,用它声明的类型变量表示可以被某些编译器未知的因素更改,比如:操作系统,硬件或者其他线程等
  • volatile关键字是否能保证线程安全?

    千次阅读 2021-01-13 11:27:04
    虽然volatile提供了同步的机制,但是知识一种弱的同步机制,如需要强线程安全,还需要使用synchronized。Java语言提供了一种稍弱的同步机制,即volatile变量,用来确保将变量的更新操作通知到其他线程。当把变量声明...
  • C/C++volatile关键字详解

    千次阅读 2016-09-12 10:03:23
     C/C++ 中的 volatile 关键字和 const 对应,用来修饰变量,通常用于建立语言级别的 memory barrier。这是 BS 在 "The C++ Programming Language" 对 volatile 修饰词的说明: A volatile specifier is a hint ...
  • volatile关键字 C++与Java的区别

    千次阅读 2020-03-12 02:09:57
    在Java中也有volatile关键字,Java之中volatile的作用是: 确保内存可见性:读写变量具有全局有序性,保证当前线程读到的值是内存中最新的,而不是缓存中的值。但是volatile关键字并不保证线程读写变量的相对顺序,...
  • C++Volatile关键字[参考].pdf
  • 满意答案yyvalentine2016.11.26采纳率:56%等级:11已帮助:4891人C/C++ 中的 volatile 关键字和 const 对应,用来修饰变量,通常用于建立语言级别的 memory barrier。volatile 关键字是一种类型修饰符,用它声明的...
  • 浅谈C语言的volatile关键字

    千次阅读 2018-07-29 17:44:33
    对于volatile关键字我们平时很少用到,但是有时候它就派上用场了,所以下面我们浅谈一下(如果你要搞嵌入式编程,抱歉此处小二的层次帮不了你,┭┮﹏┭┮) 注:此处使用的是C++编译器 没有volatile关键字 来看...
  • volatile关键字作用

    2017-06-12 09:09:38
    volatile关键字volatile关键字是C/C++众多关键字中的一个,但不常用。我们知道,为了提高程序程序执行的效率。大多数编译器都会对齐进行优化。优化级别由低到高分为:-O0~ -O3。但有时候,编译器的这种优化也会导致...
  • C/C++中的volatile关键字和const对应,用来修饰变量,用于告诉编译器该变量值是不稳定的,可能被更改。使用volatile注意事项: (1). 编译器会对带有volatile关键字的变量禁用优化(A volatile specifier is a hint to...
  • 【C/C++面试必备】volatile 关键字

    千次阅读 多人点赞 2021-07-20 07:24:20
    本文来讲解一下 C/C++ 中的关键字 volatile。在日常的使用中很少使用到,但是,在面试中经常被提起,下面具体来看一下。 volatile作用是什么呢? volatile 意思是易变的,是一种类型修饰符,在C/C++中用来阻止...
  • volatile关键字是一种类型修饰符,用它声明的类型变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问。 精确地说就是,优化器在用到这个变量时必须每次都小心地重新读取这个变量的值...
  • C/C++volatile 关键字

    2021-01-27 14:23:50
    C/C++volatile 关键字 C/C++ 中的 volatile 关键字和 const 对应,用来修饰变量。volatile 关键字是一种类型修饰符,用它声明的类型变量表示可以被某些编译器未知的因素更改,比如:操作系统、硬件或者其它线程...
  • C语言32个关键字 关键字 说明 auto 声明自动变量 short 声明短整型变量或函数 int 声明整型变量或函数 long 声明长整型变量或函数 float 声明浮点型变量或函数 double 声明双精度...
  • C/C++ 中的 volatile 关键字和 const 对应,用来修饰变量,通常用于建立语言级别的 memory barrier。这是 BS 在 "The C++ Programming Language" 对 volatile 修饰词的说明: A volatile specifier is a hint to a...
  • const_cast使用实例:代码转自:IT男汉:C++ const_cast用法 #include<iostream> using namespace std; void ConstTest1() { const int a = 5; int *p; p = const_cast<int*>(&a); (*p)..
  • 因此也解释了,为什么有了MESI技术,我们还需要增加volatile关键字,因为不加的话,就没有屏障,也就没法使用store forwarding和处理 invalid Queue技术,还是可能发生重排序。 可以参考文章:...
  • C++volatile关键字

    2021-03-06 23:33:34
    volatile介绍 volatile 限定符告知计算机,代理(而不是变量所在的程序)可以改变该变量的值。 通常,它被用于硬件地址以及在其他程序或者同时运行的线程中共享数据。 例如,一个地址上可能储存着当前的始终时间...
  • Volatile关键字的详解

    2021-02-01 14:13:28
    大部分人认识Volatile,也是从这个特征出发,而这也是本文揭秘的C/C++ Volatile的第一个特征。 Volatile:易变的 在介绍C/C++ Volatile关键词的”易变”性前,先让我们看看以下的两个代码片段,以及他们对应的汇编...
  • 详细介绍了Java中的volatile关键字的概念、特性,随后从代码、字节码、JVM、底层CPU4个层面,深入系统底层的分析了volatile关键字的实现,最后介绍了volatile关键字的使用!
  • Java并发编程:volatile关键字解析  volatile这个关键字可能很多朋友都听说过,或许也都用过。在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果。在Java 5之后,volatile...
  • 在IAR编译器选择高级优化的时候,会造成一些volatile变量被当成常量,从而造成很多问题。 “循环变量没有volatile造成高级优化是那些延时被忽略掉,从而lcd工作不稳定造成的” “检查代码吧,最高优化等级的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,979
精华内容 11,591
关键字:

volatile关键字的作用c++

c++ 订阅