java - 为什么在迭代之间 hibernate 会导致循环中的操作比不 hibernate 的情况花费更长的时间

Question

附加程序(见末尾)在执行时产生以下输出:

..........
with sleep time of 0ms
  times= [1, 1, 1, 0, 1, 1, 0, 1, 1, 0]
  average= 0.7
..........
with sleep time of 2000ms
  times= [2, 2, 2, 2, 2, 1, 2, 2, 2, 2]
  average= 1.9

在这两种情况下，都会执行完全相同的代码，即从程序开始时实例化的 Random 对象中重复获取下一个值。首先执行的预热方法应该在实际测试开始之前触发任何类型的 JIT 优化。

谁能解释造成这种差异的原因？到目前为止，我每次都能够在我的机器上重复这个结果，这是在带有 java 7 的多核 Windows 系统上执行的。

一件有趣的事情是，如果测试执行的顺序是相反的，也就是说，如果我们在没有延迟的循环之前运行有延迟的循环，那么时序更相似(无延迟循环实际上需要更长的时间):

..........
with sleep time of 2000ms
  times= [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
  average= 2.0
..........
with sleep time of 0ms
  times= [2, 3, 3, 2, 3, 3, 2, 3, 2, 3]
  average= 2.6

据我所知，在操作方法中没有创建任何对象，并且当通过分析器运行它时，似乎从未触发过垃圾收集。一个疯狂的猜测是，一些值被缓存在处理器本地缓存中，当线程进入休眠状态时，该缓存会被刷新，然后当线程唤醒时，它需要从主内存中检索值，但这并不是那么快。然而，这并不能解释为什么颠倒顺序会有所不同......

我最初观察到这种行为(促使我编写这个示例测试类)的真实情况是 XML 解码，我注意到，一个接一个地快速连续地重复解码同一文档产生的时间比执行相同的操作，但在调用 unmarshal 之间有延迟(通过 sleep 或手动产生延迟)。

代码如下:

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Tester
{
    public static void main(String[] args) throws InterruptedException
    {
        warmUp(10000);

        int numRepetitions = 10;
        runOperationInALoop(numRepetitions, 0);
        runOperationInALoop(numRepetitions, 2000);
    }

    private static void runOperationInALoop(int numRepetitions, int sleepTime) throws InterruptedException
    {
        List<Long> times = new ArrayList<Long>(numRepetitions);
        long totalDuration = 0;

        for(int i=0; i<numRepetitions; i++)
        {
            Thread.sleep(sleepTime);

            long before = System.currentTimeMillis();
            someOperation();
            long duration = System.currentTimeMillis() - before;

            times.add(duration);
            totalDuration = totalDuration + duration;

            System.out.print(".");
        }
        System.out.println();

        double averageTimePerOperation = totalDuration/(double)numRepetitions;

        System.out.println("with sleep time of " + sleepTime + "ms");
        System.out.println("  times= " + times);
        System.out.println("  average= " + averageTimePerOperation);
    }

    private static void warmUp(int warmUpRepetitions)
    {
        for(int i=0; i<warmUpRepetitions; i++)            
        {
            someOperation();
        }
    }

    public static int someInt;
    public static Random random = new Random(123456789L);

    private static void someOperation()
    {
        for(int j=0; j<50000; j++)
        {
            someInt = ((int)random.nextInt()*10) + 1;
        }
    }
}

Answer 1

即使 sleep 时间很短(您可能会发现 10 毫秒就足够长了)，您也会放弃 CPU，并且数据、指令和分支预测缓存会受到干扰甚至被清除。即使进行像 System.currentTimeMillis() 或更准确的 System.nanoTime() 这样的系统调用，也可以在很小的程度上做到这一点。

AFAIK，避免放弃核心的唯一方法是忙等待并使用线程关联将线程锁定到核心。这样可以最大限度地减少此类干扰，并意味着您的程序在低延迟情况下(即亚毫秒级任务很重要时)的运行速度可以提高 2-5 倍。

为了你的利益

http://vanillajava.blogspot.co.uk/2012/01/java-thread-affinity-support-for-hyper.html

http://vanillajava.blogspot.co.uk/2012/02/how-much-difference-can-thread-affinity.html