首页 > TAG信息列表 > java-memory-model

java-发生在Executor.submit()之前的保证

Javadoc of Executor interface说： Memory consistency effects: Actions in a thread prior to submitting a Runnable object to an Executor happen-before its execution begins, perhaps in another thread. Java语言规范的哪一部分可以保证？还是仅因为实现使用一些内部同步？

java-是否有工具来确定程序是否按照JLS中的定义“正确同步”？

Java语言规范7(JLS7-17.4.5)定义了一个“正确同步”的程序,如下所示：“当且仅当所有顺序一致的执行都没有数据竞争时,程序才正确同步”. JLS7-17.4.5还指出： Without correct synchronization, very strange, confusing and counterintuitive behaviors are possible. 因此,从程序

非易失性字段首先从另一个线程访问对象(java)

我已经在某个服务器类型的应用程序上工作了一段时间,我发现它的设计挑战了我在Java中看到内存一致性(可以这么说)的方式. 此应用程序使用NIO,因此I / O线程数量有限(它们仅用于网络I / O,而没有其他功能；它们永远不会终止,但可能会阻塞以等待更多工作). 每个连接在内部都表示为特定

java – 为什么在CopyOnWriteArrayList中需要setArray()方法调用

在CopyOnWriteArrayList.java中,在方法集中(int index,E element) 下面 public E set(int index, E element) { final ReentrantLock lock = this.lock; lock.lock(); try { Object[] elements = getArray(); Object oldValue = elements[index];

java – 如果我们覆盖finalize方法,为什么可以增加分配阶段？

我听说在Joshua Bloch的书中写道,如果我们覆盖finalize方法,分配和内存收集可能会增加到430倍. 对我来说很明显,内存收集可以更慢地工作,因为gc需要额外的迭代来释放内存. 但为什么分配阶段可以增加？解决方法:我搜索了原始声明： On my machine, the time to create and destroy a s

java中的指令重新排序和发生之前的关系

参见英文答案 > How to understand happens-before consistent                                    4个 在Java Concurrency In Practice一书中,我们被告知可以通过编译器,JVM在运行时甚至由处理器重新排序程序的指令.因此,我们应该假设执行

java – 调度程序可以挂起一个线程并执行另一个线程/工作吗？

让我们有以下代码(我们将在单核CPU上运行它)： Runnable runnable1 = new Runnable() { @Override public void run() { System.out.println("runnable_1_1"); System.out.println("runnable_1_2"); } }; Runnable runnable2 = new Runnable()

Java内存模型中的部分构造对象

我遇到了以下代码in an article somewhere on the Internet： public class MyInt { private int x; public MyInt(int y) { this.x = y; } public int getValue() { return this.x; } } 文章指出 Constructors are not treated special

Java在线程启动之前发生

我在某处读到,开始一个线程对关系之前的事件有一些特殊的影响.现在我不确定我的代码是否在关系之前保证了这一点,所以请赐教. 我有一个Dispatcher线程和一个实现Runnable接口的Worker类. Dispatcher线程创建Worker的新实例,并通过带元素的add方法填充Worker实例中的LinkedList. 然

java – 声明两个字段是否足够？

我现在正在编写Java ME应用程序.据我所知,它使用旧的Java内存模型,因为它的功能受限于Java 1.3.关于此模型提供的volatile关键字的唯一保证是所有读取和写入都直接通过主内存而不是缓存. 考虑以下代码： class BillHelper { volatile HttpConnection con; volatile InputStr

java – compareAndSet不成功操作的内存效果

Java通过其原子类公开CAS操作,例如 boolean compareAndSet(expected,update) JavaDocs指定了compareAndSet操作的内存效果,如下所示： compareAndSet and all other read-and-update operations such as getAndIncrement have the memory effects of both reading and writi

java – 发生之前和volatile的重新排序

有多个代码示例,假设以下指令(1)和(2)不能重新排序： int value; volatile boolean ready; // ... value = 1; // (1) ready = true; // (2) > “What Volatile Means In Java” > “Details zu volatile-Variablen”(德语)> Stack Overflow answer 后一个Stack Overflow应

是否有可能在Java中有效地实现seqlock？

另一个question让我想知道是否可以使用Java中的易失版本计数器有效地实现seqlock. 这是一个原型实现,因为只有一个编写器线程的情况： class Seqlock { private volatile long version = 0; private final byte[] data = new byte[10]; void write(byte[] newData) { ver

Java内存模型操作

我试图了解Java Memory Model,但我在行动方面遇到了一些麻烦.我理解一个动作的定义为< t,k,v,u>,但我不太明白程序是如何分解为动作的,以及这些动作是如何抽象的. 我的第一个假设是行动是原子的. var1 = var2将分为两个动作 – 读取var2和写入var1,但是示例here表明var1 = var2是一

java – 最终实例变量的安全发布是否可传递给非最终二次引用？

我知道在构造函数完成后,最终的实例变量会安全地发布到所有线程.但是,我想知道这是否仍然安全,如果最终的实例变量包含对包含非最终实例变量的对象的引用.构造函数完成后,永远不会更改此辅助非最终实例变量.请考虑以下示例： public class NonFinalImmutable { private Iterable

Java内存模型中的同步和易失性如何工作？

在“Effective Java”一书中： // Broken! - How long would you expect this program to run? public class StopThread { private static boolean stopRequested; public static void main(String[] args) throws InterruptedException { Thread backgroundThre

Java内存模型和重新排序操作

我的问题是针对帖子的： https://shipilev.net/blog/2014/safe-public-construction/ public class UnsafeDCLFactory { private Singleton instance; public Singleton get() { if (instance == null) { // read 1, check 1 synchronized (this) { if (ins

在Java中发生的事先机制

我在Java中遇到过关于先发生机制的问题.这是一个例子： public class MyThread extends Thread { int a = 0; volatile int b = 0; public void run() { try { Thread.sleep(500); } catch (InterruptedExcept

java – 没有volatile的懒惰初始化/ memoization

看起来Java内存模型没有定义本地缓存的“刷新”和“刷新”,相反人们只是为了简单而这样称呼它,但实际上“发生在之前”的关系意味着以某种方式刷新和刷新(如果你可以解释一下,但不是问题的直接部分). 这让我非常困惑,因为关于Java Memory Model in the JLS的部分不是以易于理解的方

java – 当我们说某个特定的数据结构是缓存友好的时候是什么意思？

我经常读到链表数据结构及其变体跳过列表在并行硬件中是缓存友好的.这是什么意思 ？有人可以用一种易于理解的方式解释. 编辑：上下文是在this link.解决方法: I often read that linked list data structure and its variant skiplists are cache friendly 链表和类似结构不是CPU缓

Java中synchronized关键字的记忆效应

这可能之前已经得到解答,但由于问题的复杂性,我需要确认.所以我重新提出这个问题 问题1：当线程进入同步块时,内存屏障将包括触摸的任何字段,而不仅仅是我同步的对象的字段？因此,如果在同步块内修改了许多对象,则在线程内存缓存之间会有大量内存移动. Thread 1 object.field1 = ""; s

java – 如果线程B希望看到线程A发生的变化,那么最后的变化只能是一个易变量而不是全部吗？

我看过this answer,它说明了如何： Under the new memory model, when thread A writes to a volatile variable V, and thread B reads from V, any variable values that were visible to A at the time that V was written are guaranteed now to be visible to B. 因此,

java – 同步数据读/写主存储器

当一个synchronized方法完成时,它是否只将它修改的数据推送到主存储器或所有成员变量,类似于同步方法执行时,它是否只读取主内存所需的数据,还是清除所有缓存中的成员变量并从主内存中读取它们的值？例如 public class SharedData { int a; int b; int c; int d; public S

java – JMM保证最终为对象的字段和非最终引用

我尝试理解最终字段的语义. 让研究代码： public class App { final int[] data; static App instance; public App() { this.data = new int[]{1, 0}; this.data[1] = 2; } public static void main(String[] args) { new Thread(

使用join()的Java多线程程序在计算相邻数字的总和时给出了错误的结果

我写了这个简单的多线程程序来添加1到100,000的数字.当我运行它时,我得到不同的值作为最终结果(值小于预期5000050000).当我仅使用一个线程执行程序时,它给出了正确的结果.程序也适用于较小的值,例如100.可能出错的是什么？提前致谢. class Calculation { private long total=0;