System.nanoTime与System.currentTimeMillis
根据它的文档，System.nanoTime从一些固定但任意的起源时间开始返回纳秒。 但是，在所有的x64机器上，我尝试了下面的代码，有时间跳转，移动了固定的原点时间。 我的方法可能存在一些缺陷，使用替代方法获取正确的时间（这里是currentTimeMillis）。 然而，测量相对时间（持续时间）的主要目的也受到负面影响。
当我比较不同的队列和LMAX的Disruptor时，我发现这个问题试图测量延迟，有时我会得到非常负的延迟。 在这些情况下，开始和结束时间戳由不同的线程创建，但延迟时间是在这些线程完成后计算的。
我的代码在这里使用nanoTime需要花费时间，计算currentTimeMillis时间中的固定原点，并比较调用之间的原点。 因为我必须在这里提出一个问题：这段代码有什么问题？ 为什么它观察到违反固定来源合同的情况？ 或者不是？
import java.text.*;
/**
* test coherency between {@link System#currentTimeMillis()} and {@link System#nanoTime()}
*/
public class TimeCoherencyTest {
static final int MAX_THREADS = Math.max( 1, Runtime.getRuntime().availableProcessors() - 1);
static final long RUNTIME_NS = 1000000000L * 100;
static final long BIG_OFFSET_MS = 2;
static long startNanos;
static long firstNanoOrigin;
static {
initNanos();
}
private static void initNanos() {
long millisBefore = System.currentTimeMillis();
long millisAfter;
do {
startNanos = System.nanoTime();
millisAfter = System.currentTimeMillis();
} while ( millisAfter != millisBefore);
firstNanoOrigin = ( long) ( millisAfter - ( startNanos / 1e6));
}
static NumberFormat lnf = DecimalFormat.getNumberInstance();
static {
lnf.setMaximumFractionDigits( 3);
lnf.setGroupingUsed( true);
};
static class TimeCoherency {
long firstOrigin;
long lastOrigin;
long numMismatchToLast = 0;
long numMismatchToFirst = 0;
long numMismatchToFirstBig = 0;
long numChecks = 0;
public TimeCoherency( long firstNanoOrigin) {
firstOrigin = firstNanoOrigin;
lastOrigin = firstOrigin;
}
}
public static void main( String[] args) {
Thread[] threads = new Thread[ MAX_THREADS];
for ( int i = 0; i < MAX_THREADS; i++) {
final int fi = i;
final TimeCoherency tc = new TimeCoherency( firstNanoOrigin);
threads[ i] = new Thread() {
@Override
public void run() {
long start = getNow( tc);
long firstOrigin = tc.lastOrigin; // get the first origin for this thread
System.out.println( "Thread " + fi + " started at " + lnf.format( start) + " ns");
long nruns = 0;
while ( getNow( tc) < RUNTIME_NS) {
nruns++;
}
final long runTimeNS = getNow( tc) - start;
final long originDrift = tc.lastOrigin - firstOrigin;
nruns += 3; // account for start and end call and the one that ends the loop
final long skipped = nruns - tc.numChecks;
System.out.println( "Thread " + fi + " finished after " + lnf.format( nruns) + " runs in " + lnf.format( runTimeNS) + " ns (" + lnf.format( ( double) runTimeNS / nruns) + " ns/call) with"
+ "nt" + lnf.format( tc.numMismatchToFirst) + " different from first origin (" + lnf.format( 100.0 * tc.numMismatchToFirst / nruns) + "%)"
+ "nt" + lnf.format( tc.numMismatchToLast) + " jumps from last origin (" + lnf.format( 100.0 * tc.numMismatchToLast / nruns) + "%)"
+ "nt" + lnf.format( tc.numMismatchToFirstBig) + " different from first origin by more than " + BIG_OFFSET_MS + " ms"
+ " (" + lnf.format( 100.0 * tc.numMismatchToFirstBig / nruns) + "%)"
+ "nt" + "total drift: " + lnf.format( originDrift) + " ms, " + lnf.format( skipped) + " skipped (" + lnf.format( 100.0 * skipped / nruns) + " %)");
}};
threads[ i].start();
}
try {
for ( Thread thread : threads) {
thread.join();
}
} catch ( InterruptedException ie) {};
}
public static long getNow( TimeCoherency coherency) {
long millisBefore = System.currentTimeMillis();
long now = System.nanoTime();
if ( coherency != null) {
checkOffset( now, millisBefore, coherency);
}
return now - startNanos;
}
private static void checkOffset( long nanoTime, long millisBefore, TimeCoherency tc) {
long millisAfter = System.currentTimeMillis();
if ( millisBefore != millisAfter) {
// disregard since thread may have slept between calls
return;
}
tc.numChecks++;
long nanoMillis = ( long) ( nanoTime / 1e6);
long nanoOrigin = millisAfter - nanoMillis;
long oldOrigin = tc.lastOrigin;
if ( oldOrigin != nanoOrigin) {
tc.lastOrigin = nanoOrigin;
tc.numMismatchToLast++;
}
if ( tc.firstOrigin != nanoOrigin) {
tc.numMismatchToFirst++;
}
if ( Math.abs( tc.firstOrigin - nanoOrigin) > BIG_OFFSET_MS) {
tc.numMismatchToFirstBig ++;
}
}
}
现在我做了一些小的改变。 基本上，我将两个currentTimeMillis调用之间的nanoTime调用括起来，以查看该线程是否已重新调度（这应该比currentTimeMillis更高的分辨率）。 在这种情况下，我忽略了循环周期。 实际上，如果我们知道nanoTime足够快（就像Ivy Bridge这样的新体系结构），我们可以在nanoTime中使用currentTimeMillis。
现在长度> 10ms的跳跃消失了。 相反，我们计算每个线程距离第一个起点超过2ms的距离。 在我测试过的机器上，运行时间为100s时，通常会有200.000次跳转。 对于那些我认为currentTimeMillis或nanoTime可能不准确的案例。
如前所述，每次计算一个新的原点意味着您容易出错。
// ______ delay _______
// v v
long origin = (long)(System.currentTimeMillis() - System.nanoTime() / 1e6);
// ^
// truncation
如果您修改程序以便计算原点差异，则会发现它非常小。 我测量了大约200ns的平均值，这对于时间延迟来说是正确的。
使用乘法而不是除法（这应该是没有溢出的好几百年），你还会发现计算出来的等式检验失败的起源数量要大得多，约为99％。 如果错误的原因是由于时间延迟造成的，那么只有在延迟与最后一次相同时才会通过。
一个更简单的测试是在nanoTime的一些次数调用上累积经过时间，并查看它是否用第一次和最后一次调用进行检查：
public class SimpleTimeCoherencyTest {
public static void main(String[] args) {
final long anchorNanos = System.nanoTime();
long lastNanoTime = System.nanoTime();
long accumulatedNanos = lastNanoTime - anchorNanos;
long numCallsSinceAnchor = 1L;
for(int i = 0; i < 100; i++) {
TestRun testRun = new TestRun(accumulatedNanos, lastNanoTime);
Thread t = new Thread(testRun);
t.start();
try {
t.join();
} catch(InterruptedException ie) {}
lastNanoTime = testRun.lastNanoTime;
accumulatedNanos = testRun.accumulatedNanos;
numCallsSinceAnchor += testRun.numCallsToNanoTime;
}
System.out.println(numCallsSinceAnchor);
System.out.println(accumulatedNanos);
System.out.println(lastNanoTime - anchorNanos);
}
static class TestRun
implements Runnable {
volatile long accumulatedNanos;
volatile long lastNanoTime;
volatile long numCallsToNanoTime;
TestRun(long acc, long last) {
accumulatedNanos = acc;
lastNanoTime = last;
}
@Override
public void run() {
long lastNanos = lastNanoTime;
long currentNanos;
do {
currentNanos = System.nanoTime();
accumulatedNanos += currentNanos - lastNanos;
lastNanos = currentNanos;
numCallsToNanoTime++;
} while(currentNanos - lastNanoTime <= 100000000L);
lastNanoTime = lastNanos;
}
}
}
该测试确实表明原点是相同的（或者至少该误差是零均值）。
据我所知， System.currentTimeMillis()方法确实有时会跳转，这取决于底层操作系统。 我有时自己观察过这种行为。
所以你的代码给我的印象是你试图获得System.nanoTime()和System.currentTimeMillis()之间的偏移时间。 您应该尝试仅通过调用System.currentTimeMillis()来观察此偏移量，然后才可以说System.nanoTimes()会导致跳转。
顺便说一下，我不会假装spec（javadoc描述与某个固定点相关的System.nanoTime() ）总是完美实现。 你可以看看多核CPU或CPU频率变化会对System.nanoTime()所需的行为产生负面影响的讨论。 但有一点是肯定的。 System.currentTimeMillis()更受制于任意跳转。