“隐式” java中的同步？

Question

当我有这样的方法时，

public void unsynchronizedMethod(){
  callSynchronizedMethod();
  //dosomestuff after this line
}

这是否意味着在 unsynchronizedMethod() 方法中调用 callSynchronizedMethod() 后的所有内容都是隐式同步的？

Answer 1

不会。锁会在 callSynchronizedMethod() 结束时释放。

Answer 2

同步以简单的方式定义：

• 对于 synchronized 方法：在该方法的执行中
• 对于 synchronized 块：在该块的执行中

以下是相关摘录Java 语言规范第三版：

JLS 14.19 同步声明

同步语句：

1. 代表执行线程获取互斥锁，
2. 执行一个块，
3. 然后释放锁。

当执行线程拥有锁时，其他线程无法获取该锁。

synchronized 方法在语义上与应用于整个方法的 synchronized 语句相同 (§JLS 8.4.3.6。锁可以从 this 获取（如果它是实例方法）或 类 与方法的类关联的对象（如果它是静态方法；您不能在静态上下文中引用此）

。回答原来的问题，给出这个片段：

public void unsynchronizedMethod(){
  callSynchronizedMethod();

  doSomeUnsynchronizedStuff(); // no "implicit synchronization" here
}

仅与关键部分的同步，早期同步不会产生任何挥之不去的影响。

是设计使然：您应该始终努力最大限度地减少

• 请注意，这 Java 第 2 版，第 67 项：避免过度同步

相关问题

• Java 中的同步方法和同步块有什么区别？
• 同步块与同步方法？

Answer 3

不，不是。

同步意味着一次只有一个线程执行代码。

但是在 callSynchronizedMethod() 之后，线程可以同时以不同的顺序再次运行代码。

Answer 4

不，不会有隐式同步。同步在块或函数范围内工作。同步块之外的任何内容都不会同步。

下面的示例代码表明了这一点。如果方法同步，它将始终打印 0。

class example extends Thread{
   //Global value updated by the example threads
   public static volatile int value= 0;
    public void run(){
    while(true)//run forever
       unsynchMethod();

   }
   public void unsynchMethod(){
     synchronizedMethod();
    //Count value up and then back down to 0
    for(int i =0; i < 20000;++i)
       value++;//reads increments and updates value (3 steps)
    for(int i = 0; i < 20000;++i)
       value--;//reads decrements and updates value (3 steps)
      //Print value 
      System.out.println(value);
   }
   //Classlevel synchronized function
   public static synchronized void synchronizedMethod(){
      //not important
   }
   public static void main(String... args){
    example a = new example();
    example b = new example();
    a.start();
    b.start();
   }

}

如果同步，我的结果应该为 0：

4463
6539
-313
-2401
-3012
...