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

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 otimization.

任何人都可以解释这种差异的原因吗？到目前为止,我每次都能在我的机器上重复这个结果,这是在带有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(通过睡眠或手动生成的延迟)之间的延迟.

这是代码:

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

当您睡眠很短的时间(您可能会发现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