Tag: volatile
Java Double Locking – 有人可以更直接地解释为什么直觉不起作用？
我在这里找到了以下代码： http ： //en.wikipedia.org/wiki/Double-checked_locking#Usage_in_Java 我试图理解为什么在某些情况下这不起作用。 我阅读了“微妙”问题的解释，并且使用volatile将解决问题，但我有点困惑。 // Broken multithreaded version // “Double-Checked Locking” idiom class Foo { private Helper helper = null; public Helper getHelper() { if (helper == null) { synchronized(this) { if (helper == null) { helper = new Helper(); } } } return helper; } // other functions and members… } 基本上，我是否正确地认为这会失败，因为synchronized块中的helper […]
通过ReentrantLock访问的字段是否需要volatile关键字？
我的问题是指使用ReentrantLock是否保证字段的可见性与synchronized关键字提供的方面相同。 例如，在下面的类A中 ，字段sharedData不需要声明为volatile，因为使用了synchronized关键字。 class A { private double sharedData; public synchronized void method() { double temp = sharedData; temp *= 2.5; sharedData = temp + 1; } } 但是，对于使用ReentrantLock的下一个示例，字段上的volatile关键字是否必要？ class B { private final ReentrantLock lock = new ReentrantLock(); private volatile double sharedData; public void method() { lock.lock(); try { double temp = sharedData; temp […]
Java易失性和缓存一致性
如果在硬件级别实现高速缓存一致性，为什么我们需要volatile呢？ 任何核心/处理器都应该获得最新的价值？ 或者它是完全处理不同的问题？
原始类型的易失性或同步？
在Java中，如果变量的大小小于或等于32位，则赋值是primefaces的，但如果大于32位则不是。 在双重或长期分配的情况下，使用什么（易失性/同步）会更有效？ 喜欢， volatile double x = y; synchronized不适用于原始参数。 在这种情况下如何使用synchronized？ 当然我不想锁定我的课程，所以不应该使用它。
Java和C＃中的volatile语义背后的原因是什么？
C＃和Java都定义了这一点 * volatile读取具有获取语义 * volatile写入具有发布语义 我的问题是： 这是定义volatile的唯一正确方法吗？ 如果没有，如果语义被颠倒，事情就会大不相同，也就是说 volatile读取具有释放语义 volatile写入具有获取语义
挥发性如何实际起作用？
在Java中将变量标记为volatile可确保每个线程都看到上次写入的值而不是某些过时值。 我想知道这是如何实现的。 JVM是否发出特殊指令来刷新CPU内存或其他内容？
如果执行顺序（几乎）不受影响，如何在严重的性能下降中分配变量结果？
在玩multithreading时，我可以观察到与AtomicLong（以及使用它的类，例如java.util.Random）相关的一些意外但严重的性能问题，我目前没有解释。 但是，我创建了一个简约示例，它基本上由两个类组成：一个类“Container”，它保存对volatile变量的引用;一个类“DemoThread”，它在线程执行期间对“Container”的实例进行操作。 请注意，对“Container”和volatile long的引用是私有的，并且从不在线程之间共享（我知道这里不需要使用volatile，它仅用于演示目的） – 因此，“DemoThread”的多个实例应该完美运行在多处理器机器上并行，但由于某种原因，它们没有（完整的例子在这篇文章的底部）。 private static class Container { private volatile long value; public long getValue() { return value; } public final void set(long newValue) { value = newValue; } } private static class DemoThread extends Thread { private Container variable; public void prepare() { this.variable = new Container(); } public void run() […]
如果我在Spring Framework中的@PostConstruct中初始化它们，我应该将对象属性标记为volatile吗？
假设我在Spring单例bean @PostConstruct （简化代码）中做了一些初始化： @Service class SomeService { public Data someData; // not final, not volatile public SomeService() { } @PostConstruct public void init() { someData = new Data(….); } } 我应该担心someData对其他bean的可见性并将其标记为volatile吗？ （假设我无法在构造函数中初始化它） 第二种情况：如果我在@PostConstruct 覆盖值（例如在构造函数中进行显式初始化或初始化之后），那么写入@PostConstruct 将不会首先写入此属性？
JIT可以在某些表达式中将两个易失性读取合并为一个吗？
假设我们有一个volatile int a 。 一个线程呢 while (true) { a = 1; a = 0; } 而另一个线程呢 while (true) { System.out.println(a+a); } 现在，JIT编译器发出对应于2*a而不是a+a汇编是不合法 a+a吗？ 一方面，易失性读取的目的是它应该始终从内存中消失。 另一方面，两个读取之间没有同步点，所以我看不出primefaces地处理a+a是违法的，在这种情况下我看不出像2*a这样的优化会如何破坏规范。 参考JLS将不胜感激。
java变量本身是否安全？ 更新变量时？
假设我有两个线程更新一个对象，一个线程从该对象读取而没有同步。 显然，这是运行条件。 但是，我想知道变量本身是否只能部分写入。 public class CommonObject extends Object { static int memberVar=-1; } public class Input1Thread extends Thread { public void run() { while(true) CommonObject.memberVar = 1 } } public class Input2Thread extends Thread { public void run() { while(true) CommonObject.memberVar = 2; } } public class OutputThread extends Thread { public void run() { […]
