Tag: volatile

while循环与空身体检查挥发性整数 – 这是什么意思？

我正在看一个有以下几行的C ++类： while( x > y ); return x – y; x和y是volatile inttypes的成员variables。 我不明白这个构造。 我在这里find代码存根： https ： //gist.github.com/r-lyeh/cc50bbed16759a99a226 。 我想这不能保证是正确的，甚至工作。

使用__asm__ __volatile__（“”：：：“memory”）

基本上__asm__ __volatile__ ()是做什么的，ARM架构的"memory"意义是什么？

为什么不在System.Double和System.Long上挥发？

一个像我这样的问题已经被问到 ，但我的情况有点不一样。 问题是，“为什么在C#typesSystem.Double和System.Int64等中不允许使用volatile关键字？ 乍一看，我回答了我的同事，“在32位机器上，这些types至less需要两个滴答才能进入处理器，而.Net框架的目的是抽象出处理器的具体细节。 “ 他回应说：“如果因为处理器特定的问题阻止你使用某个function，那么它就不是抽象的东西！” 他暗示着一个处理器特定的细节不应该显示给一个使用像程序员那样“抽象”细节的框架的人。 所以，框架（或者C＃）应该把这些东西抽象出来，并且为System.Double等提供相同的保证（无论是信号量，内存屏障还是其他）。 我认为框架不应该增加信号量的易变性，因为程序员并不期望这样的关键字有这样的开销，因为信号量对于32位types不是必需的。 64位types的更大开销可能会令人吃惊，因此，对于.Net框架来说，更好的办法就是不允许它，并且如果开销可以接受的话，让你在更大的types上做自己的信号量。 这导致我们调查volatile关键字的全部内容。 （见本页）。 该页面在说明中指出： 在C＃中，在字段上使用volatile修饰符可以保证对该字段的所有访问使用VolatileRead或VolatileWrite。 嗯….. VolatileRead和VolatileWrite都支持我们的64位types！ 我的问题是， “为什么在C#types的System.Double和System.Int64等中不允许使用volatile关键字？

“对易失性字段的引用不会被视为易变的”影响

下面的代码 using System.Threading; class Test { volatile int counter = 0; public void Increment() { Interlocked.Increment(ref counter); } } 引发以下编译器警告： "A reference to a volatile field will not be treated as volatile" 我在这里做错了什么来提出这个警告？ 为什么编译器会提醒我呢？

易失性保证和无序执行

重要的编辑我知道在发生两个任务的线程 “发生之前”我的问题是有可能是另一个线程读取“b”非空，而“a”仍然为空。 所以我知道，如果您从之前调用setBothNonNull（…）的线程调用doIt（） ，那么它不能抛出NullPointerException exception 。 但是如果从另一个线程调用doIt（） 而不是调用setBothNonNull（…） ？ 请注意，这个问题是关于volatile关键字volatile保证：它不是关于synchronized关键字（所以请不要回答“你必须使用同步”，因为我没有任何问题来解决：我只是想了解有关无序执行的volatile担保（或缺乏担保）。 假设我们有一个包含两个volatilestring引用的对象，这些引用被构造函数初始化为null，并且我们只有一种方法来修改这两个string：通过调用setBoth（…）并且我们只能将它们的引用设置为非-null引用（只允许构造函数将它们设置为null）。 例如（这只是一个例子，现在还没有问题）： public class SO { private volatile String a; private volatile String b; public SO() { a = null; b = null; } public void setBothNonNull( @NotNull final String one, @NotNull final String two ) { a = one; b = two; } public […]

发生在与Java中的易失性字段和同步块之间的关系之前 – 及其对非易失性variables的影响？

我对线程的概念还是比较陌生的，试着更多地了解它。 最近，我遇到了一篇关于杰里米·曼森（Jarremy Manson）的“ 什么是挥发性手段（What Volatile Means in Java）”的博文，他写道： 当一个线程写入一个volatilevariables，另一个线程看到写入时，第一个线程告诉第二个线程关于所有内存的内容，直到写入该volatilevariables。 在线程1写入[volatile] ready之前，线程1看到的所有内存内容必须对线程2可见，然后它读取ready的值true 。 [强调自己加] 现在，这是否意味着在写入volatilevariables时线程1的内存中保存的所有variables（volatile或不）在线程2读取该volatilevariables之后将变为可见？ 如果是这样， 是否有可能从官方的Java文档/ Oracle来源拼凑这个声明？ 从哪个Java版本开始这个工作？ 特别是，如果所有线程共享以下类variables： private String s = "running"; private volatile boolean b = false; 线程1首先执行以下操作： s = "done"; b = true; 线程2然后执行（线程1写入易失性字段后）： boolean flag = b; //read from volatile System.out.println(s); 这将保证打印“完成”？ 如果不是将b声明为volatile而是将写入和读取放入synchronized块，会发生什么？ 此外，在题为“ 线程之间共享静态variables？ ”的讨论中，@TREE 写道 ： 不要使用volatile来保护多个共享状态。 为什么？ […]

有没有使用一个易变的长期？

我偶尔使用一个volatilevariables来处理两个线程读取/写入的情况，而不希望取出锁的开销（或潜在的死锁风险）。 例如一个定时器线程定期更新一个inttypes的ID，这个ID在某些类上被作为getter使用： public class MyClass { private volatile int id; public MyClass() { ScheduledExecutorService execService = Executors.newScheduledThreadPool(1); execService.scheduleAtFixedRate(new Runnable() { public void run() { ++id; } }, 0L, 30L, TimeUnit.SECONDS); } public int getId() { return id; } } 我的问题：鉴于JLS只保证32位读取将是primefaces是有没有使用一个易变的长期的任何一点？ （即64位）。 警告 ：请不要回复说，使用volatile over synchronized是一种预优化的情况; 我很清楚如何/何时使用synchronized但有些情况下volatile是最好的。 例如，当定义一个在单线程应用程序中使用的Spring bean时，我倾向于支持volatilevariables，因为不能保证Spring上下文将初始化主线程中的每个bean的属性。

易失性结构语义

将结构typesvariables的实例声明为volatile（如果它的字段在可重入代码中访问），还是必须声明结构的特定字段为volatile？ 换句话说，在以下两者之间的语义差异（如果有的话）是什么？ typdef struct { uint8_t bar; } foo_t; volatile foo_t foo_inst; 和 typedef struct{ volatile uint8_t bar; } foo_t; foo_t foo_inst; 我认识到将一个指针型variables声明为volatile（例如volatile uint8_t * foo）只是告诉编译器foo指向的地址可能会改变，而不会声明foo指向的值。 我不清楚类比是否适用于结构型variables。

java中volatile关键字最简单易懂的例子

我正在阅读关于Java中的volatile关键字，并完全理解它的理论部分。 但是，我正在寻找的是一个很好的例子，它显示了如果variables不是不稳定的，那么会发生什么。 下面的代码片段不能按预期工作（ 来自aioobe ） class Test extends Thread { boolean keepRunning = true; public void run() { while (keepRunning) { } System.out.println("Thread terminated."); } public static void main(String[] args) throws InterruptedException { Test t = new Test(); t.start(); Thread.sleep(1000); t.keepRunning = false; System.out.println("keepRunning set to false."); } } 理想情况下，如果keepRunning不是易失性的，线程应该继续不断地运行。 但是，它几秒钟后停止。 我有两个基本的问题： 任何人都可以用例子解释volatile吗？ 不符合JLS的理论。 挥发替代品是否同步？ […]

指针声明为常量以及易失性

在阅读时，我遇到了这种types的声明和下面的一行 – const volatile char *p=(const volatile char *) 0x30; p的值仅由外部条件改变 我没有得到什么外部条件。 而且这种宣言的实际用途是什么？