Question

I currently have the following code:

public static int currentTimeMillis()
{
    long millisLong = System.currentTimeMillis();
    while ( millisLong > Integer.MAX_VALUE )
    {
        millisLong -= Integer.MAX_VALUE;
    }
    return (int)millisLong;
}

which returns the current time in an int format (not exactly, but it can be used for time differences). For very good reasons, I can’t use long.

Yes, I am just interested in the difference between two calls, and this approach works well. But it just looks wrong. I know that. And inefficient. I know. So my questions is, how can I improve it?

I need a function that returns an int such that:

int x1 = currentTimeMillis(); //my function
long y1 = System.currentTimeMillis();

.....

int x2 = currentTimeMillis();
long y2 = System.currentTimeMillis();

// here, x2 - x1 must be equal to y2 - y1

EDIT:

FYI, I want to do this for benchmarking. I’m running tests on multiple threads in parallel, the stop event is triggered by an external component. I’m also serializing the data in a way that only supports int, and the object I’m serializing can not have long members.

Answer 1

Your function does essentially the same as:

public static int currentTimeMillis() {
    return (int) (System.currentTimeMillis() % Integer.MAX_VALUE);
}

The above is probably what you’re looking for. The modulus operator % returns the remainder of the division. I would only wrap it in another class which hides this away. It’s namely confusing to have “current time in millis” as an int with the wrong value. Something like:

Stopwatch stopwatch = Stopwatch.start();

// ...

int elapsed = stopwatch.elapsed();

with

public final class Stopwatch {

    private long start;

    private Stopwatch() {
        start = System.currentTimeMillis();
    }

    public static Stopwatch start() {
        return new Stopwatch();
    }

    public int elapsed() {
        return (int) (System.currentTimeMillis() - start);
    }

}

This is also much better in order to prevent problems when the start time is less than Integer.MAX_VALUE and the end time is larger than Integer.MAX_VALUE which thus overflows back to Integer.MIN_VALUE and continues from there.