Getting Milliseconds Since 1970 in Java: From System.currentTimeMillis() to java.time.Instant

Introduction

In Java programming, obtaining milliseconds since the Unix epoch (January 1, 1970 UTC midnight) is a common requirement for timestamp generation, performance measurement, logging, and other applications. This article systematically introduces two primary approaches: the traditional System.currentTimeMillis() and the java.time.Instant class introduced in Java 8.

The System.currentTimeMillis() Method

System.currentTimeMillis() is the most fundamental time retrieval method in Java, available since early versions. It returns a long value representing the difference in milliseconds between the current time and 1970-01-01 UTC midnight.

long currentMillis = System.currentTimeMillis();
System.out.println("Current timestamp: " + currentMillis);

As per Java documentation, this method directly measures the time difference without timezone conversion, always based on UTC. This makes it reliable for precise timestamp needs, though note that the return value may be affected by system clock adjustments.

The Java 8 java.time Framework

Java 8 introduced a new date-time API—the java.time package—where the Instant class specifically models a point on the time-line. Compared to System.currentTimeMillis(), Instant offers richer functionality and better type safety.

import java.time.Instant;

// Get the current Instant
Instant now = Instant.now();

// Convert to milliseconds
long epochMilli = now.toEpochMilli();
System.out.println("Milliseconds: " + epochMilli);

// Also get seconds
long epochSecond = now.getEpochSecond();
System.out.println("Seconds: " + epochSecond);

Instant.now() essentially calls Clock.systemUTC().instant(), ensuring time is always UTC-based. This provides consistency and reliability, especially in cross-timezone applications.

Comparison and Selection Guidelines

Both methods are functionally similar but have key differences:

1. Precision: System.currentTimeMillis() provides millisecond precision, while Instant can support nanosecond precision (via getNano()).
2. API Design: As an object, Instant supports method chaining and interoperability with other time classes like LocalDateTime and ZonedDateTime.
3. Version Compatibility: For pre-Java 8 versions, System.currentTimeMillis() is mandatory; Java 8 and later versions should prefer the java.time API.

In practice, if only a simple millisecond timestamp is needed without complex time calculations, System.currentTimeMillis() is a lightweight choice. For richer time operations or nanosecond precision, the Instant class is more appropriate.

Handling Specific Time Points

Beyond current time, one can compute milliseconds between any UTC time point and 1970-01-01. The Instant class facilitates this:

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;

// Create an Instant for a specific time
LocalDateTime specificTime = LocalDateTime.of(2023, 1, 1, 0, 0, 0);
Instant specificInstant = specificTime.toInstant(ZoneOffset.UTC);

// Calculate milliseconds
long specificMillis = specificInstant.toEpochMilli();
System.out.println("Milliseconds for 2023-01-01 UTC: " + specificMillis);

This approach ensures accuracy and consistency, particularly when dealing with historical or future timestamps.

Conclusion

Obtaining milliseconds since 1970-01-01 UTC in Java can be achieved through multiple methods. The traditional System.currentTimeMillis() is straightforward for basic needs, while Java 8's java.time.Instant offers a modern, feature-rich solution. Developers should choose based on specific requirements, Java version, and precision needs. With Java updates, the java.time API has become the standard for date-time handling, recommended for adoption in new projects.