7

附加的程序（见最后）在执行时会产生以下输出：

..........
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 之间有延迟（通过睡眠或手动产生的延迟）。

这是代码：

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;
        }
    }
}
4

3 回答 3

9

当你睡眠即使是很短的时间（你可能会发现 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

于 2012-10-16T22:05:06.690 回答
2

当您的线程进入睡眠状态时，您实际上是在对 JVM 说：该线程在接下来的 X 毫秒内什么也不做。JVM 很可能在此时唤醒各种后台线程来做他们的事情（例如 GC），这很可能会导致对存储在处理器缓存中的数据进行更新。当你重新唤醒线程时，它的一些数据可能不再在缓存中（快），但很可能会转移到主内存（慢）。

查看http://mechanical-sympathy.blogspot.co.uk/了解更多关于低级缓存效果的讨论。

于 2012-10-16T22:20:49.253 回答
0

  1. 无法保证sleep()睡眠时间与您指定的时间完全一致。Javadoc 中有一个特定的声明。

  2. System.currentTimeMillis()具有系统相关粒度，您可以通过运行相对较少的迭代（如 2000 次）来暴露该粒度。您应该将其乘以至少 10 以脱离粒度区域。在 Windows 上，我相信它高达 16 毫秒。

于 2012-10-17T04:36:17.227 回答