从我从Herb Sutter和其他人那里读到的内容,您会认为volatile并发编程是完全正交的概念,至少就C/C++而言.
但是,在GCC 实现中,所有std::atomic的成员函数都有volatile限定符.安东尼威廉姆斯的实施也是如此std::atomic.
那么什么是交易,我的atomic<>变量需要volatile与否？
volatile是告诉编译器不要优化引用,这样每次读/写都不会使用存储在寄存器中的值,而是进行实际的内存访问.我可以理解它对一些普通变量有用,但不明白如何volatile影响指针.
volatile int *p = some_addr;
int a = *p; // CPU always has to load the address, then does a memory access anyway, right?
如果它被宣布为有什么区别int *p = some_addr？
我正在阅读Java中的volatile关键字并完全理解它的理论部分.
但是,我正在寻找的是一个很好的案例,它展示了如果变量不是易变的话会发生什么.
下面的代码片段无法正常工作(来自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,则线程应该继续无限运行.但是,它会在几秒钟后停止.
我有两个基本问题: -
根据:
http://www.ibm.com/developerworks/library/j-jtp03304/
在新的内存模型下,当线程A写入易失性变量V,并且线程B从V读取时,在写入V时对A可见的任何变量值现在都保证对B可见.
互联网上的许多地方声明以下代码永远不应该打印"错误":
public class Test {
volatile static private int a;
static private int b;
public static void main(String [] args) throws Exception {
for (int i = 0; i < 100; i++) {
new Thread() {
@Override
public void run() {
int tt = b; // makes the jvm cache the value of b
while (a==0) {
}
if (b == 0) {
System.out.println("error");
}
}
}.start();
}
b = 1;
a = 1;
}
}
b …
将结构类型变量的实例声明为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;
我认识到将指针类型的变量声明为volatile(例如,volatile uint8_t*foo)只是告诉编译器foo指向的地址可能会改变,而不会声明foo指向的值.我不清楚类比是否适用于结构类型的变量.
我有一个由硬件供应商报告的理论上的（非确定性的、难以测试的、实践中从未发生过的）硬件问题，其中对某些内存范围的双字写入可能会破坏任何未来的总线传输。
虽然我没有在 C 代码中明确写任何双字，但我担心编译器被允许（在当前或未来的实现中）将多个相邻的字分配合并为一个双字分配。
编译器不允许重新排序 volatile 的分配，但不清楚（对我而言）合并是否算作重新排序。我的直觉说是，但我之前已经被语言律师纠正过！
例子：
typedef struct
{
volatile unsigned reg0;
volatile unsigned reg1;
} Module;
volatile Module* module = (volatile Module*)0xFF000000u;
// two word stores, or one double-word store?
module->reg0 = 1;
module->reg1 = 2;
（我会单独询问我的编译器供应商，但我很好奇标准的规范/社区解释是什么。）
在阅读时我遇到了这种类型的声明和以下行 -
const volatile char *p=(const volatile char *) 0x30;
p的值仅由外部条件改变
我没有得到什么是外部条件.还有这种宣言的实际用途是什么？
某些语言提供的volatile修饰符被描述为在读取支持变量的内存之前执行"读取内存屏障".
读取存储器屏障通常被描述为一种方法,用于确保CPU在屏障之后执行读取之前执行读取之前所请求的读取.但是,使用此定义,似乎仍然可以读取过时值.换句话说,以特定顺序执行读取似乎并不意味着必须查询主存储器或其他CPU以确保读取的后续值实际上反映了读取屏障时系统中的最新值或随后写入阅读障碍.
因此,volatile是否真的保证读取最新值或者只是(喘气!)读取的值至少与屏障之前的读取一样是最新的？还是其他一些解释？这个答案有什么实际意义？
我已经查看了SO中的其他volatile和Atomicxxxx问题(包括这个),并阅读了java.util.current.atomic的描述,我对细微差别不太满意.
如果我在尝试使用volatile boolean和之间做出决定AtomicBoolean,除了AtomicBoolean提供的原子读取 - 修改 - 写入操作之外是否存在实际差异？(例如compareAndSet()和getAndSet())
假设我有
volatile boolean flag;
然后一个或多个线程设置标志(但不清除它).如果我有一个线程读取标志,如果设置,执行操作,然后清除标志,是否volatile足够？
AtomicBoolean的成本是否高于volatile布尔值
volatile boolean似乎需要内存防护,AtomicBoolean似乎需要内存防护+根据java.util.current.atomic描述对CAS操作进行一些小锁定)我的直觉调用是使用AtomicBoolean并且是安全的,但我想了解是否有任何情况可以使用volatile boolean(例如,如果我有数千个实例,性能是一个问题).
我偶尔会使用一个volatile实例变量,在这种情况下,我有两个线程读取/写入它并且不希望获得锁定的开销(或潜在的死锁风险); 例如,计时器线程定期更新在某些类上作为getter公开的int ID:
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位读取将是原子有任何一点曾经使用挥发性长时间？(即64位).
警告:请不要回复说使用volatile结束synchronized是预优化的情况; 我很清楚如何/何时使用,synchronized但有些情况volatile更可取.例如,在定义用于单线程应用程序的Spring bean时,我倾向于使用volatile实例变量,因为无法保证Spring上下文将初始化主线程中的每个bean的属性.