为什么调用方法的Java字节码会隐式获取和释放监视器？

Question

我一直在阅读 Java 虚拟机指令集< /a> 并注意到，当使用指令调用标记为同步的方法（例如，invokestatic、invokevirtual 等）时，由特定的字节码指令来获取接收者对象上的监视器。类似地，当从方法返回时，由离开该方法的指令决定，以在该方法同步时释放监视器。这看起来很奇怪，因为有明确的monitorenter和monitorexit字节码用于管理监视器。 JVM 以这种方式设计这些指令，而不是仅仅编译方法以在适当的情况下包含 MonitorEnter 和 MonitorExit 指令，是否有特殊原因？

Answer 1

早在 90 年代中期，还没有 Java JIT 编译器，微同步被认为是一个非常好的主意。

因此，您经常调用这些同步方法。甚至 Vector 也有它们！您无需解释额外的字节码即可处理。

但不仅仅是在代码运行时。类文件更大。额外的说明，还设置了 try/finally 表并验证是否有一些顽皮的东西没有被插入。

只是我的猜测。

Answer 2

你问为什么有两种方法做同样的事情？

当一个方法与市场同步时，再有监视器进入/退出指令将是多余的。如果它只有monitorenter/exit指令，您将无法从外部看到该方法是同步的（无需阅读实际代码）。

有多个示例说明了两种或多种方法可以完成同一件事。每个都有相对的优点和缺点。 （例如，许多单字节指令是两字节指令的简短版本）

编辑：我必须在问题中遗漏一些东西，因为调用者不需要知道被调用者是否同步

public static void main(String... args) {
    print();
    printSynchronized();
    printSynchronizedInternally();
}

public static void print() {
    System.out.println("not synchronized");
}

public static synchronized void printSynchronized() {
    System.out.println("synchronized");
}

public static  void printSynchronizedInternally() {
    synchronized(Class.class) {
        System.out.println("synchronized internally");
    }
}

产生代码

public static void main(java.lang.String[]);
  Code:
   0:   invokestatic    #2; //Method print:()V
   3:   invokestatic    #3; //Method printSynchronized:()V
   6:   invokestatic    #4; //Method printSynchronizedInternally:()V
   9:   return

public static void print();
  Code:
   0:   getstatic   #5; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   ldc #6; //String not synchronized
   5:   invokevirtual   #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8:   return

public static synchronized void printSynchronized();
  Code:
   0:   getstatic   #5; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   ldc #8; //String synchronized
   5:   invokevirtual   #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8:   return

public static void printSynchronizedInternally();
  Code:
   0:   ldc_w   #9; //class java/lang/Class
   3:   dup
   4:   astore_0
   5:   monitorenter
   6:   getstatic   #5; //Field java/lang/System.out:Ljava/io/PrintStream;
   9:   ldc #10; //String synchronized internally
   11:  invokevirtual   #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   14:  aload_0
   15:  monitorexit
   16:  goto    24
   19:  astore_1
   20:  aload_0
   21:  monitorexit
   22:  aload_1
   23:  athrow
   24:  return
  Exception table:
   from   to  target type
     6    16    19   any
    19    22    19   any

}

Answer 3

通过将锁管理委托给调用者，现在可以进行一些优化。例如，假设您有一个如下所示的类：

public class Foo {

    public synchronized void bar() {
        // ...
    }

}

并假设该调用者类使用它：

public class Caller {

    public void call() {
        Foo foo = new Foo();
        // implicit MONITORENTER on foo's lock
        foo.bar();
        // implicit MONITOREXIT on foo's lock
    }

}

根据转义分析，JVM 知道 foo 永远不会转义线程。正因为如此，它可以避免隐式的 MONITORENTER 和 MONITOREXIT 指令。

在 JVM 的早期，当速度是一种稀有商品时，避免不必要的锁可能更受性能驱动。

Answer 4

您是否在问为什么同步方法使用显式监视器进入和退出指令，而 JVM 可以通过查看方法的属性来推断它们？

我猜这是因为，除了方法之外，还可以同步任意代码块：

synchronized( some_object ){ // monitorentry some_object
   System.out.println("I am synchronised!");
}                            // monitorexit some_object

因此，对同步方法和同步块使用相同的指令是有意义的。

Answer 5

正在搜索同一个问题，并发现了以下文章。看起来方法级同步生成的字节代码比块级同步稍微高效一些。对于块级同步，会生成显式字节代码来处理方法级同步未完成的异常。因此，一个可能的答案可能是，这两种方法用于使方法级同步稍微快一些。

http://www.ibm.com/developerworks/ibm/library/it- haggar_bytecode/