“Time is the scarcest resource and unless it is managed, nothing else can be managed.” — Peter Drucker

Definition of Clocks 🕐

1. The Monotonic Clock: A Consistent Timekeeper

The Monotonic clock is a reliable time source that guarantees non-decreasing time values, meaning it only moves forward and remains unaffected by system clock changes such as manual adjustments or daylight saving time.

Advantages of Monotonic Clock:

• Consistency: Ideal for measuring elapsed time as it remains unaffected by system clock modifications.
• Reliability: Provides a stable time reference, essential for performance benchmarking and timeout operations.

Disadvantages of Monotonic Clock:

• Lacks Real-World Context: Doesn’t provide actual date and time, making it unsuitable for logging or time stamping events.

2. The Wall Clock: Real-World Time Representation

The Wall clock represents the system clock, reflecting the current date and time as perceived by the user. It is subject to changes and adjustments like daylight saving time or manual updates.

Advantages of Wall Clock:

• Contextual Relevance: Provides real-world date and time, making it useful for logging, scheduling, and time stamping events.
• User-Friendly: Aligns with human perception of time, making it easier to understand in context-sensitive applications.

Disadvantages of Wall Clock:

• Inconsistency: Susceptible to changes that can disrupt time measurements, potentially causing inaccuracies in elapsed time calculations.

Now that we know what clocks are available in the system, now let’s see how do we practically use them.

Current Approach

System.currentTimeMillis() is a commonly used method to retrieve the current time in milliseconds since the Unix epoch (January 1, 1970). Despite its popularity, it has significant drawbacks.

How System.currentTimeMillis() works:

• Retrieves time from the system clock, which can be adjusted manually or automatically.
• Can return inconsistent values if the system time is changed during execution.

Drawbacks of System.currentTimeMillis():

• Inaccuracy: Unreliable for measuring elapsed time due to possible system clock adjustments.
• Inconsistency: Can lead to errors in applications requiring precise time intervals, such as animations or timeout mechanisms.

Measuring Time in Kotlin

Traditional Time Measurement Approach

Before Kotlin’s Timing API, we resorted to various methods to measure time, like using System.nanoTime() or System.currentTimeMillis() . While they work perfectly, they come with their own set of challenges.

Crafting custom timing solutions often lead to verbose and intricate code. Managing start and end times manually resulted in code that was not only repetitive but also prone to errors.

import java.lang.System

fun main() {
    // Record the start time
    val startTime = System.nanoTime()

    // Code block whose execution time we want to measure
    Thread.sleep(200) // Simulating some work with a sleep of 200 milliseconds

    // Record the end time
    val endTime = System.nanoTime()

    // Calculate the elapsed time in nanoseconds
    val elapsedTime = endTime - startTime

    // Convert the elapsed time to milliseconds for better readability
    val elapsedTimeMillis = elapsedTime / 1_000_000

    println("Elapsed time: $elapsedTime ns")
    println("Elapsed time: $elapsedTimeMillis ms")
}

Timing API: Revolutionizing Time Measurement in Kotlin

Kotlin’s Timing API is transforming how we measure time, offering a simple, accurate, and efficient solution that addresses the limitations of traditional methods. This groundbreaking innovation allows developers to focus on optimizing their code without the hassle of manual time tracking. The API eliminates the need for custom extensions or specialized timing constructs, enabling the measurement of execution time in a standardized and reliable way. This results in reduced code complexity and fewer potential errors.

With the Timing API, developers gain access to a powerful tool that streamlines time measurement, making it more accessible and effective. This enhancement significantly improves the precision and clarity of code, marking a major shift in time measurement practices and aligning with our continuous pursuit of excellence and efficiency in application development.

The Timing API simplifies time measurement with functions like measureTime and measureTimedValue. Tracking the duration of code execution is as easy as placing your code within these functions to obtain the execution time. This feature is invaluable for working faster and smarter, free from complexity.

Accuracy is a key benefit of the Timing API. It provides precise and informative data on code performance, which is crucial for identifying and resolving issues, ensuring smooth project operation.

Additionally, the Timing API enhances collaboration and maintenance. Its intuitive syntax ensures that any team member can easily read and write the code, simplifying future revisions and modifications. This makes the Timing API not only beneficial for present needs but also a foundation for future success.

Basic Execution Time Measurement

import kotlin.time.measureTime

fun main() {
  
  val executionTime = measureTime {
    // ... your code block ...
  }

  println("The code block took: $executionTime")
  
}

In this example, measureTime neatly wraps around your code block, measuring its execution time, which is then returned as a Duration object for logging or further use.

Measuring Time and Retrieving a Result

import kotlin.time.measureTimedValue

fun main() {
   
  val (result, duration) = measureTimedValue {
    // ... your code block that produces a result ...
  }
  
  println("Result: $result, took: $duration")
}

Important : Please note that there is a d after “measureTime”, please make sure to include this!

The measureTimedValue function offers a convenient way to obtain both the result of a code block and the duration it took to execute, providing a seamless blend of functionality and performance insight.

Kotlin’s Timing API not only fosters more expressive, concise, and readable code but also introduces the Duration object, enhancing the handling and representation of time measurements. This object aligns with the API’s principles of precision and simplicity, while also enabling advanced time measurement and manipulation capabilities.

Duration API

The Duration object is a key part of Kotlin’s Timing API, showing the language’s dedication to accuracy, clarity, and ease of use. It represents time durations with great flexibility and precision, giving us a rich set of tools to work with and change time spans in our apps.

Duration makes it easy to switch between time units, such as seconds, milliseconds, or nanoseconds. This is important when your app’s logic depends on precise timing.

Let’s see how Duration works in practice, and how it improves the way we deal with time in our apps:

import kotlin.time.Duration.Companion.minutes
import kotlin.time.Duration.Companion.seconds

fun main() {

  val durationFromMinutes = 3.minutes
  val durationInSeconds = durationFromMinutes.inWholeSeconds
  val durationInMilliseconds = durationFromMinutes.inWholeMilliseconds

  println("Duration: $durationFromMinutes or $durationInSeconds seconds or $durationInMilliseconds milliseconds")

}

Arithmetic with Time, Simplified

import kotlin.time.seconds

fun main() {

  val initialDuration = 15.seconds
  val bufferTime = 5.seconds
  val totalDuration = initialDuration + bufferTime

  println("Total Duration: $totalDuration")

}

Here, Duration enables straightforward arithmetic operations, allowing you to calculate total times, buffers, or intervals effortlessly, making your code not just more intuitive but also more maintainable.

The Duration class provides a number of functions and properties to create and convert durations in different units, such as seconds, milliseconds, nanoseconds, and so on.

To convert a duration to a Long number of milliseconds, we can use the property inWholeMilliseconds.

val milliseconds = duration.inWholeMilliseconds

To get the absolute value of a duration, we can use the property absoluteValue:

val absoluteDuration = duration.absoluteValue

There are also functions to add, subtract, multiply, or divide durations, such as plus, minus, times, and div. These functions return a new duration as the result of the operation.

import kotlin.time.seconds
import kotlin.time.minutes

fun main() {

  val timeInSeconds= 15.seconds
  val timeInMinutes= 3.minutes
  val totalDuration = timeInMinutes + timeInSeconds

  println("Total Duration: $totalDuration")

}

For more information about the Duration class and its functions and properties, please refer to the official documentation.

In the next article, we’ll delve into Advanced Time measurements in Kotlin.

Leave a comment for any doubt or follow me on X(previously twitter) for more updates or queries.

Keep supporting guys, will be back soon with another topic to discuss.

Keep Learning. Keep Growing.

This article is previously published on proandroiddev.com