Instant class

By / 22 May 2025 / 2 minutes of reading

The java.time.Instant class represents a specific moment on the time-line in UTC (Coordinated Universal Time). It is a machine-readable timestamp and is commonly used for recording timestamps in logs, measuring time intervals, or working with system clocks.

  • It is immutable and thread-safe.
  • The epoch reference point is 1970-01-01T00:00:00Z (UTC).

Commonly Used Methods of Instant

Simple Program Using Instant

import java.time.Instant;
import java.time.Duration;

public class SimpleInstantExample {
    public static void main(String[] args) {
        Instant start = Instant.now();

        // Simulate some processing time
        for (int i = 0; i < 1000000; i++);

        Instant end = Instant.now();

        Duration timeElapsed = Duration.between(start, end);
        System.out.println("Start time: " + start);
        System.out.println("End time: " + end);
        System.out.println("Elapsed time in milliseconds: " + timeElapsed.toMillis());
    }
}

Problem Statement

Paani and Mahesh are developers at BankTech Inc. tasked with building a Secure Transaction Logger. Each time a transaction is completed, they must record:

  • The timestamp of the transaction.
  • The processing duration.
  • Whether the transaction completed before or after a specific business timestamp.

They must use the Instant class to implement this and determine if the processing met the SLA (Service Level Agreement).

import java.time.Instant;
import java.time.Duration;

public class TransactionLogger {

    public static void main(String[] args) {
        // Reference timestamp for comparison (e.g., 2025-05-22T10:00:00Z)
        Instant slaDeadline = Instant.parse("2025-05-22T10:00:00Z");

        // Simulate transaction start
        Instant transactionStart = Instant.now();
        System.out.println("Transaction started at: " + transactionStart);

        // Simulate processing delay
        simulateTransactionProcessing();

        // Simulate transaction end
        Instant transactionEnd = Instant.now();
        System.out.println("Transaction ended at: " + transactionEnd);

        // Calculate processing time
        Duration duration = Duration.between(transactionStart, transactionEnd);
        System.out.println("Transaction processing time: " + duration.toMillis() + " ms");

        // Check SLA compliance
        if (transactionEnd.isBefore(slaDeadline)) {
            System.out.println("Transaction completed before SLA deadline.");
        } else {
            System.out.println("Transaction missed the SLA deadline.");
        }
    }

    private static void simulateTransactionProcessing() {
        try {
            Thread.sleep(500); // Simulating transaction delay
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
/*
Transaction started at: 2025-05-22T09:59:59.123Z
Transaction ended at: 2025-05-22T10:00:00.623Z
Transaction processing time: 1500 ms
Transaction completed before SLA deadline.
*/

The Instant class in the java.time package is a precise, efficient, and immutable representation of a single moment on the UTC timeline. It is particularly useful for:

  • Timestamping events (like transactions, log entries).
  • Measuring elapsed time between two events.
  • Comparing time instants to enforce SLAs or deadlines.
  • System-level or backend operations where human-readable dates are not necessary.

With its machine-centric nature, Instant complements human-readable classes like LocalDateTime and ZonedDateTime, offering robust tools for developers handling both real-world and technical time-tracking needs. Its thread safety, immutability, and clean API make it a preferred choice for modern Java applications.

Related Posts

Scroll to Top