Question

Hi all I have a piece of code which looks like this:

public class Test {
    public static void main(String args[]) {
        long a = System.currentTimeMillis(); // line 1
        long b = System.currentTimeMillis(); // line 2
        assert b - a >= 0;

        long y = System.nanoTime(); // line 5
        long z = System.nanoTime(); // line 6
    }
}

So IERS stated that the next leap second is to occur immediately after 30^th June 2012 11:59.9.

I was wondering if I’m right to say that if line 1 is run at 0.9 seconds after 30^th June 2012 11:59.9 turns 1^st July 2012 00:00.0,

And line 2 is run at 0.1 second after line 1,

The result of b - a could be negative ? (-900 milliseconds)

If that’s the case, is it true that if line 5 is run at 0.9 seconds after 30^th June 2012 11:59.9 turns 1^st July 2012 00:00.0,

And line 6 is run at 0.1 second after line 5,

The result of z - y could be negative ? (-900,000,000 nanoseconds?)

Answer 1

System.nanoTime should be monotonically increasing — if you have two calls to it, A and B, and A happens-before B, then A <= B. But in practice, you can actually observe nanoTime going "backwards."

nanoTime is determined by an internal counter on the CPU whose starting time is essentially arbitrary (which is why it can’t be used to determine wall clock time). This can cause a problem in multi-core environment, since one core’s internal timer may have a different starting point than another’s. Hotspot tries to compensate for this, but it doesn’t always succeed, so you can in fact see nanoTime ticking backwards in some situations.

There was a recent discussion about this on the concurrency-interest mailing list. See in particular this email which links to this bug report, and this email which talks about the workaround (which doesn’t seem to work, though I’m not sure why). The bug report has a fair amount of detail.