对象与 byte[0] 作为锁

Question

我之前评论过这个问题（“为什么java.lang.Object不是抽象的？”）指出我听说使用 byte[0] 作为锁比使用 java.lang.Object 稍微更有效。我确信我在某处读过这篇文章，但我不记得在哪里：有谁知道这是否属实？

我怀疑这是由于 byte[0] 的实例化需要比 Object 稍少的字节代码，尽管有人指出 byte[0] > 需要额外的存储空间才能存储长度字段，因此听起来这可能会抵消任何好处。

Answer 1

使用 java.lang.instrument.Instrumentation 检查大小：
Object 使用 8 个字节，byte[0] 需要 16 个字节。 （不确定大小是否以字节为单位，未记录）。

我还花时间创建了一个 Object 和一个 byte[0] （2 次）：Object 是赢家。

（所有测试均在 DELL 笔记本电脑、Intel 2GHz、Windos XP 上运行）

使用客户端 VM

java version "1.6.0_16"
Java(TM) SE Runtime Environment (build 1.6.0_16-b01)
Java HotSpot(TM) Client VM (build 14.2-b01, mixed mode)

an implementation-specific approximation of the amount of storage
Object  = 8
byte[0] = 16

time to create 1000000000 instances
Object:  elapsed=11,140   cpu=9,766    user=9,703    [seconds]
byte[0]: elapsed=18,248   cpu=15,672   user=15,594   [seconds]

time to create 1000000000 instances
Object:  elapsed=11,135   cpu=9,828    user=9,750    [seconds]
byte[0]: elapsed=18,271   cpu=15,547   user=15,469   [seconds]

使用服务器 VM

java version "1.6.0_16"
Java(TM) SE Runtime Environment (build 1.6.0_16-b01)
Java HotSpot(TM) Server VM (build 14.2-b01, mixed mode)

an implementation-specific approximation of the amount of storage
Object  = 8
byte[0] = 16

time to create 1000000000 instances
Object:  elapsed=8,441    cpu=7,156    user=7,125    [seconds]
byte[0]: elapsed=11,237   cpu=8,609    user=8,500    [seconds]

time to create 1000000000 instances
Object:  elapsed=8,501    cpu=7,234    user=7,156    [seconds]
byte[0]: elapsed=11,023   cpu=8,688    user=8,641    [seconds]

我将继续使用new Object()，不仅仅是因为可读性:-)

Code

public class ObjectArrayCompare {

  private static Object o;

  public static void main(String[] args) {
    Instrumentation instr = InstrumentationAgent.getInstrumentation();
    if (instr == null) {
        System.err.println("No Instrumentation, use \"-javaagent:Instrumentation.jar\"");
        return;
    }
    System.out.println();
    System.out.println("an implementation-specific approximation of the amount of storage");
    System.out.println("Object  = " + instr.getObjectSize(new Object()));
    System.out.println("byte[0] = " + instr.getObjectSize(new byte[0]));
    System.out.println();

    final int MAX = (int) 1.0e9;
    Timer timer;
    Times times;

    for (int j = 0; j < 2; j++) {
      System.out.println("time to create " + MAX + " instances"); 
      timer = new Timer();
      for (int i = 0; i < MAX; i++) {
        o = new Object();
      }
      times = timer.times();
      System.out.println("Object:  " + times);

      timer = new Timer();
      for (int i = 0; i < MAX; i++) {
        o = new byte[0];
      }
      times = timer.times();
      System.out.println("byte[0]: " + times);

      System.out.println();
    }
  }
}

Timer^* 使用 ThreadMXBean 来获取时间。

^* Timer 是我为计时而创建的类，它不是 Java 计时器之一。

Answer 2

我很好奇，想测试一下。源代码：

public class Test {
    public static Object returnObject() {
        return new Object();
    }

    public static byte[] returnArray(){
        return new byte[0];
    }
}

字节码：

public static java.lang.Object returnObject();
  Code:
   0:   new     #2; //class java/lang/Object
   3:   dup
   4:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   7:   areturn

public static byte[] returnArray();
  Code:
   0:   iconst_0
   1:   newarray byte
   3:   areturn

所以你说得对，数组的字节码更短，因为数组创建有自己的 JVM 操作码。但这意味着什么？没什么，真的。它是虚拟机，因此绝对不能保证更少的字节码指令意味着实际物理 CPU 的工作量更少。当然，我们可以开始分析，但这毫无意义。如果确实存在差异，无论哪种方式，都永远不会重要。如今，对象创建速度快得令人难以置信。在测量总时间之前，您可能必须开始使用 long 作为循环索引。

Answer 3

根据
Java 语言规范, "所有类和数组类型继承了 Object 类的方法”，所以我不知道 byte[0] 如何能够变得更高效。

这对于 第一版来说似乎是正确的规范以及：“数组类型的超类被认为是对象”。

Answer 4

恕我直言，使用数组更有可能让读者感到困惑。

创建较少的对象比创建更多的对象更有效，因此，如果它确实创建了足够多的重要对象，那么您就创建了太多对象。

Answer 5

Java中使用空数组作为锁对象的模式与性能关系不大。

空数组（甚至new Object[0]）更可取，因为它们是可序列化的。通过使用new Object()，您将放弃自动序列化。

我习惯了这样做（从不关心性能）：

private final Object lock = new Object[0];

原始数组需要更少的字节码来创建，所以也许 new byte[0] 会“更好”。

请参阅：可以为可序列化类设置瞬态锁吗？

Answer 6

你的问题提到了“效率”，但没有说你追求什么样的效率。到目前为止，答案涉及对象的大小，但是在任一表示中取消引用和使用内在锁的运行时成本应该是相同的。

您还可以比较使用内在锁与使用 java.util.concurrent.locks.ReentrantLock 显式地或您自己编写的 AbstractQueuedSynchronizer。您是否可以容忍对单独分配的对象的额外引用需要更详细的问题来评估，但考虑到您已经在考虑字节数组，您必须考虑使用与您的this参考。