Anyone know exactly how Date works?

Question

After several postings to the long and rather fruitless thread about Date, I thought I'd try a little test for myself to see how/whether Java handles leap seconds.
Here's my code, based on Wikipedia, which says that the last UTC leap second was added on 2008/12/31:
public static void main(String... args) {
   TimeZone utc = TimeZone.getTimeZone("UTC");
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS z");
   sdf.setTimeZone(utc);
   long t = 1230768000000L; // 2009/1/1 00:00:00 UTC
   for (int s = -2; s < 3; s++) {
      Date instant = new Date(t + (s * 1000L));
      System.out.println(sdf.format(instant));
}which produces:
2008/12/31 23:59:58.000 UTC
2008/12/31 23:59:59.000 UTC
2009/01/01 00:00:00.000 UTC
2009/01/01 00:00:01.000 UTC
2009/01/01 00:00:02.000 UTC
The results surprised me, because it tends to suggest that Date's "ticker" (like Unix's) is not linear, but adjusts before/after the leap second to maintain a minute that is always 60 seconds. I also double-checked it with 31/12/1995 (which is listed in Date's documentation) and it produces similar results.
As a 3rd test, I added:
   GregorianCalendar gc1 = new GregorianCalendar(utc);
   gc1.set(1995, 11, 31, 23, 59, 58);
   gc1.set(Calendar.MILLISECOND, 0);
   GregorianCalendar gc2 = new GregorianCalendar(utc);
   gc2.set(1996, 0, 1, 0, 0, 2);
   gc2.set(Calendar.MILLISECOND, 0);
   System.out.println(String.format(
      "The difference between %s and %s is %d milliseconds",
         sdf.format(gc1.getTime()),
         sdf.format(gc2.getTime()),
         gc2.getTime().getTime() - gc1.getTime().getTime()
   ));and this produced:
The difference between 1995/12/31 23:59:58.000 UTC and 1996/01/01 00:00:02.000 UTC is 4000 milliseconds.
( which it isn't :-) )
I'd be happy for anyone to tell me if I've made a mistake, but the above results suggest to me that neither of Java's main time classes are completely safe for calculating intervals of time. Does this go along with other people's findings?
Also, does anybody know if this is machine-dependent? It was run on a Dell AMD Athlon running Vista.
Winston

Answer 1

YoungWinston wrote:
After several postings to the long and rather fruitless thread about Date, I thought I'd try a little test for myself to see how/whether Java handles leap seconds.
You seek implementation details of java.util.Date. Why don't you simply look at the source or at least start there.
Here's my code, based on Wikipedia, which says that the last UTC leap second was added on 2008/12/31:
public static void main(String... args) {
TimeZone utc = TimeZone.getTimeZone("UTC");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS z");
sdf.setTimeZone(utc);
long t = 1230768000000L; // 2009/1/1 00:00:00 UTC
for (int s = -2; s < 3; s++) {
Date instant = new Date(t + (s * 1000L));
System.out.println(sdf.format(instant));
}which produces:
2008/12/31 23:59:58.000 UTC
2008/12/31 23:59:59.000 UTC
2009/01/01 00:00:00.000 UTC
2009/01/01 00:00:01.000 UTC
2009/01/01 00:00:02.000 UTC
The results surprised me, because it tends to suggest that Date's "ticker" (like Unix's) is not linear, but adjusts before/after the leap second to maintain a minute that is always 60 seconds. I also double-checked it with 31/12/1995 (which is listed in Date's documentation) and it produces similar results.
As a 3rd test, I added:
   GregorianCalendar gc1 = new GregorianCalendar(utc);
gc1.set(1995, 11, 31, 23, 59, 58);
gc1.set(Calendar.MILLISECOND, 0);
GregorianCalendar gc2 = new GregorianCalendar(utc);
gc2.set(1996, 0, 1, 0, 0, 2);
gc2.set(Calendar.MILLISECOND, 0);
System.out.println(String.format(
"The difference between %s and %s is %d milliseconds",
sdf.format(gc1.getTime()),
sdf.format(gc2.getTime()),
gc2.getTime().getTime() - gc1.getTime().getTime()
));and this produced:
The difference between 1995/12/31 23:59:58.000 UTC and 1996/01/01 00:00:02.000 UTC is 4000 milliseconds.
( which it isn't :-) )
I'd be happy for anyone to tell me if I've made a mistake, but the above results suggest to me that neither of Java's main time classes are completely safe for calculating intervals of time. Does this go along with other people's findings?
Are you concerned that if you compute an interval of say, 1000 milliseconds, exactly 1000 milliseconds may not have actually elapsed? My guess is the answer is likely to be found in how Date.getTime() comes up with the long value.
Also, does anybody know if this is machine-dependent? It was run on a Dell AMD Athlon running Vista.
Theoretically it should not with Java being platform independent and all. It would most likely depend though on where and how Date comes up the long value in the host environment. I honestly don't know any implementation details though.