Tag: 同步

易失性读取是否发生在易失性写入之前？

我试着理解为什么这个例子是一个正确同步的程序： a – volatile Thread1: x=a Thread2: a=5 因为存在冲突的访问（存在对a的写入和读取）所以在每个顺序一致性执行中必须发生 – 在该访问之间的关系之前。 假设一个顺序执行： 1. x=a 2. a=5 1发生在2之前，为什么？

在Java中使用synchronized（Thread.currentThread（））{…}的目的是什么？

我在项目中面对以下代码： synchronized (Thread.currentThread()){ //some code } 我不明白在currentThread上使用synchronized的原因。 两者之间有什么区别吗？ synchronized (Thread.currentThread()){ //some code } 只是 //some code 你能提供一个显示差异的例子吗？ UPDATE 更详细的代码如下： synchronized (Thread.currentThread()) { Thread.currentThread().wait(timeInterval); } 它看起来就像Thread.sleep(timeInterval) 。 这是真的吗？

如何创建Synchronized arraylist

我已经像这样创建了synchronized arrayList import java.text.SimpleDateFormat; import java.util.*; class HelloThread { int i=1; List arrayList; public void go() { arrayList=Collections.synchronizedList(new ArrayList()); Thread thread1=new Thread(new Runnable() { public void run() { while(i<=10) { arrayList.add(i); i++; } } }); thread1.start(); Thread thred2=new Thread(new Runnable() { public void run() { while(true) { Iterator it=arrayList.iterator(); while(it.hasNext()) { System.out.println(it.next()); } } } […]

empty synchronized（this）{}对线程之间的内存可见性有什么意义吗？

我在StackOverflow的评论中读到了这个： 但是如果你想要安全，你可以在@PostConstruct [方法]的末尾添加简单的synchronized（this）{} [注意变量不易变化] 我认为只有在synchronized块中执行写入和读取或者至少读取是易失性时才强制执行before-before 。 引用的句子是否正确？ 空的synchronized(this) {}块是否将当前方法中更改的所有变量刷新为“一般可见”内存？ 请考虑一些场景 如果第二个线程永远不会锁定this怎么办？ （假设第二个线程读入其他方法）。 请记住，问题是： 刷新对其他线程的更改 ，而不是给其他线程一种方式（同步）来轮询原始线程所做的更改 。 在Spring @PostConstruct上下文中，很可能在其他方法中没有同步 – 正如原始评论所说。 是仅在另一个线程的第二次和后续调用中强制执行的更改的内存可见性？ （请记住，这个同步块是我们方法中的最后一次调用） – 这会将这种同步方式标记为非常糟糕的做法（第一次调用中的陈旧值）

并发访问静态方法

我有一个带有以下签名的静态方法： public static List processRequest(RequestObject req){ // process the request object and return the results. } 当同时对上述方法进行多次调用时会发生什么？ 请求是同时处理还是一个接一个地处理？

如果在synchronized方法中调用，thread.yield（）是否会丢失对象的锁定？

我理解Thread.currentThread().yield()是线程调度程序的通知，它可以将cpu周期分配给具有相同优先级的其他线程（如果有的话）。 我的问题是：如果当前线程锁定某个对象并调用yield() ，它会立即丢失该锁定吗？ 并且当线程调度程序发现没有这样的线程来分配cpu周期时，那么调用yield()的线程将再次在争取锁定它先前丢失的对象？ 我在javadoc和论坛中找不到它[http://www.coderanch.com/t/226223/java-programmer-SCJP/certification/does-sleep-yield-release-lock]有50-50个答案。 我认为yield() （比如说thread1）应该释放锁，因为如果某个相同优先级的线程（比如说thread2）想要对同一个对象进行操作，那么当线程调度程序最终将cup分配给thread2时它就有机会。

同步（this）vs synchronize（MyClass.class）

可能重复： .class的Java同步块 我正在阅读有关同步的文章 。 我对以下几点感到困惑，需要进一步澄清 1）用于同步块。 怎么样 synchronize(this){ // code } 不同于 synchronize(MyClass.class){ //code } 2）同步实例方法意味着线程必须获得对实例的独占锁定，而同步静态方法意味着线程必须获取整个类的锁定（如果我错了，请纠正我）。 因此，如果一个类有三个方法，其中一个是静态同步的，那么如果一个线程获得对该方法的锁定意味着它将获得对整个类的锁定，那么这意味着其他两个也将被锁定，没有其他方法将能够访问这两个方法，因为整个类都有锁？

JVM是否为每个对象创建一个互斥锁以实现’synchronized’关键字？ 如果没有，怎么样？

随着C ++程序员越来越熟悉Java，我看到语言级别支持锁定任意对象而没有任何声明对象支持这种锁定，这有点奇怪。 为每个对象创建互斥锁似乎是一个自动选择的高成本。 除了内存使用，互斥体在某些平台上是OS有限的资源。 如果互斥锁不可用但你的性能特征明显不同，你可以旋转锁定，我希望这会损害可预测性。 在所有情况下，JVM是否足够智能以识别特定对象永远不会成为synchronized关键字的目标，从而避免创建互斥锁？ 可以懒惰地创建互斥锁，但是这会引发一个自举需要互斥锁的自举问题，即使解决了这个问题，我也认为仍然会有一些开销用于跟踪是否已经创建了互斥锁。 所以我假设如果可以进行这样的优化，则必须在编译时或启动时完成。 在C ++中，由于编译模型这样的优化是不可能的（你不知道对象的锁是否会跨库边界使用），但是我对Java的编译和链接知道不够了解如果适用相同的限制。

从辅助线程在主线程上运行代码？

这是一个普通的Java问题，而不是Android首先关闭的问题！ 我想知道如何在主线程上运行代码，从辅助线程的上下文。 例如： new Thread(new Runnable() { public void run() { //work out pi to 1,000 DP (takes a while!) //print the result on the main thread } }).start(); 那种事情 – 我意识到我的例子有点差，因为在Java中你不需要在主线程中打印出来的东西，而且Swing也有一个事件队列 – 但是你可能需要的通用情况在后台线程的上下文中，在主线程上运行说一个Runnable。 编辑：为了比较 – 这是我在Objective-C中如何做到这一点： dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0UL), ^{ //do background thread stuff dispatch_async(dispatch_get_main_queue(), ^{ //update UI }); }); 提前致谢！

从Java中的synchronized上下文调用Thread.sleep（）

我已经读过Thread.sleep()将暂停当前运行的线程指定的时间，然后它返回到runnable状态，等待轮到它运行。 此外，如果从synchronized上下文调用， sleep()不会释放它所持有的锁。 所以我想知道什么时候会释放锁。 如果线程处于hibernate状态，永远不会有机会运行，那么它将始终保持锁定自身，然后其他线程如何进入同步方法/块。 我不确定我是否在问有效的问题。 但请帮帮我。