Check if timestamp older than 30 seconds

Question

I am trying to determine if a timestamp is older than 30 seconds, but for some reason it is coming back as older than 30 seconds when it hasn't even been a couple seconds.

Example: https://ideone.com/KLIIBz

public static Boolean cooldown(int id) {

    Calendar now = Calendar.getInstance();
    now.add(Calendar.SECOND, -secondsAgo);
    long timeAgo = now.getTimeInMillis();
    if ( cooldown.containsKey(id) ) {

        System.out.println(cooldown.get(id) + " | " + timeAgo);

        // Stored timestamp always older than timeAgo
        if ( cooldown.get(id) < timeAgo ) {

            cooldown.remove(id);

        } else {

            // This code should be executed, as I am running the function one after another from same UUID not even a second or two apart.
            return false;

        }

    }

    now = Calendar.getInstance();
    cooldown.put(id, now.getTimeInMillis());

    return true;

}

Answer 1

tl;dr

Duration
.between( then , Instant.now() )
.toNanos()
>
Duration
.ofSeconds( 30 )
.toNanos()

Using java.time

You are using troublesome old date-time classes that are now legacy, supplanted by the java.time classes.

The Instant class represents a moment on the timeline in UTC with a resolution of nanoseconds (up to nine (9) digits of a decimal fraction).

Instant start = Instant.now();
…
Instant stop = Instant.now();

Capture the span of time in between the start and stop as a Duration.

Duration duration = Duration.between( start , stop );

Represent your limit of 30 seconds.

Duration limit = Duration.ofSeconds( 30 );

Compare by calling the Comparable method of Duration::compareTo.

Boolean exceededLimit = ( duration.compareTo( limit ) > 0 );

By the way, having a collection and a method both named cooldown is not helpful.

---

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

Where to obtain the java.time classes?

• Java SE 8 and SE 9 and later
• Built-in.
• Part of the standard Java API with a bundled implementation.
• Java 9 adds some minor features and fixes.
• Java SE 6 and SE 7
• Much of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
• Android
• The ThreeTenABP project adapts ThreeTen-Backport (mentioned above) for Android specifically.
• See How to use ThreeTenABP….

The ThreeTen-Extra project extends java.time with additional classes. This project is a proving ground for possible future additions to java.time. You may find some useful classes here such as Interval, YearWeek, YearQuarter, and more.

Answer 2

Try this:

public class JavaApplication11 
{
    public static void main(String[] args)
    {
        // TODO code application logic here
        Calendar now = Calendar.getInstance();
        now.add(Calendar.SECOND, -30);//Set Calendar 30 seconds in the past.

        System.out.println(has30SecsPassed(now));
    }

    static boolean has30SecsPassed(Calendar calendar)
    {
        Long numberOfMilliSec = Calendar.getInstance().getTimeInMillis() - calendar.getTimeInMillis();
        double numberOfSecondsPassed = numberOfMilliSec / 1000.0;
        System.out.println("seconds passed: " + numberOfSecondsPassed);
        return numberOfSecondsPassed >= 30;
    }

}

Answer 3

This:

Calendar now = Calendar.getInstance();
now.add(Calendar.SECOND, -secondsAgo);
long timeAgo = now.getTimeInMillis();

is too much overhead or just getting the actual time stamp in your app... you can just call

System.currentTimeMillis();

and verify this condition between cooldown.get(id) and timeAgo

so they meet cooldown.get(id) - timeAgo < 30*1000 or not...

Answer 4

To judge from the code on Ideone that you link to, the problem is that secondsAgo is 0, not 30. You set it to 30 in the constructor, but since you never create an object from the class, the constructor is never executed. secondsAgo is a static field, so you can access it without an object and without it having been initialized. You just get the initial value that all int fields have, namely 0.

The output I see in Ideone certainly confirms what I am saying. In all lines of the form 1491194338577 | 1491194338578 the numbers are either identical or just 1 millisecond apart. Even though you have subtracted secondsAgo seconds from the Calendar object that you get timeAgo from, timeAgo is never anywhere near 30 seconds earlier than the timestamp that you put into the map a millisecond ago. So no, you are not subtracting 30 seconds; you are subtracting 0 seconds.

That said I still agree with Basil Bourque’s answer: if there is any way you can use Java 8, you should throw the Calendar class away and use Instant and Duration. You get much clearer and more readable code. Put Instant objects in your map instead of Longs and it’s suddenly self-explanatory what they are.

Answer 5

currentTimeMillis returns: the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC

Can you explain why you use it.