Performance Java7 System.identityHashCode性能

现场：

• 我正在使用XStream，它经常使用System.identityHashCode
• 我已经从IBM Java 1.5迁移到Oracle Java 7

问题是：

我发现了一个性能问题，并已确定System.identityHashCode可能是我的问题

问题:

• 有什么好的解释可以解释为什么我看到新Java的性能下降（以及从IBM到Oracle的变化）
• 我如何绕过这个瓶颈

以下是我的基准测试（都在相同的硬件上运行）：

bechmark计划的来源是：

import java.util.*;

public class HashCodeTest
{
  static int ITS = 10000000;
  static Object O = new Object();

  public static void main(String[] args)
  {
    TreeSet<Integer> large = new TreeSet<Integer>();
    Random ran = new Random();
    for (int i=0; i<10000; i++) {
      large.add(ran.nextInt());
    }

    testIdentityHashCode(large);
    testHashCode(large);
    testIdentityHashCode(large);
    testHashCode(large);
  }

  protected static void testIdentityHashCode(TreeSet<Integer> large)
  {
    long start = System.nanoTime();
    for (int i=0; i<ITS; i++) {
      Object o = new Container(large);
      System.identityHashCode(o);
    }
    long end = System.nanoTime();
    System.out.println("System.identityHashCode: " + (end-start) + " - " + (end-start)/ITS + "ns");
  }

  protected static void testHashCode(TreeSet<Integer> large)
  {
    long start = System.nanoTime();
    for (int i=0; i<ITS; i++) {
      Object o = new Container(large);
      o.hashCode();
    }
    long end = System.nanoTime();

    System.out.println("Object.hashCode: " + (end-start) + " - " + (end-start)/ITS + "ns");
  }

  private static class Container {
    private final Object o;

    public Container(Object o)
    {
      this.o = o;
    }
  }
}

import java.util.*；
公共类HashCodeTest
{
静态int-ITS=10000000；
静态对象O=新对象（）；
公共静态void main（字符串[]args）
{
树集大=新树集（）；
Random ran=新的Random（）；
对于（int i=0；i您看到了这种差异，这可能是因为System.identityHashCode需要一些时间进行内部化和/或Object.hashCode需要在方法中内联。此外，由于您在循环的每一步都实例化了一个对象，所以您实际上是在测量分配时间

试试这个：

public class HCTests {

static int ITS = 1000;

@Test
public void run() {

    Object[] o = newArray(1000);

    for (int i = 0; i < 10; i++) {
        timeHash(o);
    }

    System.out.println("----------------");

    for (int i = 0; i < 10; i++) {
        timeHash(newArray(1000));
    }

}

private Object[] newArray(int max) {
    Object[] o = new Object[max];

    for (int i = 0; i < o.length; i++) {
        o[i] = new Object();
    }

    return o;
}

private void timeHash(Object[] o) {
    //store the hashes to avoid possible dead-code elimination
    int[] hashes=new int[o.length];
    long start = System.nanoTime();

    for (int j = 0; j < ITS; j++) {
        for (int i = 0; i < o.length; i++) {
            hashes[i]=System.identityHashCode(o);
        }
    }

    long elapsed = System.nanoTime() - start;

    System.out.println("Elapsed " + elapsed + "(ns). Avg: " + (float)elapsed
            / (o.length * ITS));

    for (int i : hashes) {
        if(i==0) {
            System.out.println("Ooops, got 0 hashCode!!!");
        }
    }
}}

公共类测试{
静态int-ITS=1000；
@试验
公开募捐{
对象[]o=newArray（1000）；
对于（int i=0；i<10；i++）{
时间散列（o）；
}
系统输出打印项次（“------------------------------”）；
对于（int i=0；i<10；i++）{
timeHash（newArray（1000））；
}
}
私有对象[]新数组（int max）{
对象[]o=新对象[max]；
for（int i=0；i

对于我得到的第一个循环的输出（旧的Intel Core 2 Duo 2.1GHz）

7557271（ns）。平均值：7.557271

已过18508470秒。平均值：18.50847
…

经过2026678（ns）。平均值：2.026678

在我的第二圈

经过2142041（ns）。平均值：2.142041

已过去1951888（ns）。平均值：1.951888

经过1929891（ns）。平均值：1.929891

经过1934779（ns）。平均值：1.934779

经过1993438（ns）。平均值：1.993438

经过2133732（ns）。平均值：2.133732

已用1995882（ns）。平均值：1.995882

经过2326329（ns）。平均值：2.326329

经过1939178（北纬）。平均值：1.939178

经过2275980（ns）。平均值：2.275981

public class HCTests {

static int ITS = 1000;

@Test
public void run() {

    Object[] o = newArray(1000);

    for (int i = 0; i < 10; i++) {
        timeHash(o);
    }

    System.out.println("----------------");

    for (int i = 0; i < 10; i++) {
        timeHash(newArray(1000));
    }

}

private Object[] newArray(int max) {
    Object[] o = new Object[max];

    for (int i = 0; i < o.length; i++) {
        o[i] = new Object();
    }

    return o;
}

private void timeHash(Object[] o) {
    //store the hashes to avoid possible dead-code elimination
    int[] hashes=new int[o.length];
    long start = System.nanoTime();

    for (int j = 0; j < ITS; j++) {
        for (int i = 0; i < o.length; i++) {
            hashes[i]=System.identityHashCode(o);
        }
    }

    long elapsed = System.nanoTime() - start;

    System.out.println("Elapsed " + elapsed + "(ns). Avg: " + (float)elapsed
            / (o.length * ITS));

    for (int i : hashes) {
        if(i==0) {
            System.out.println("Ooops, got 0 hashCode!!!");
        }
    }
}}