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?

我需要一个接回<代码>int的职能。因此:

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

你的职能基本上与:

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

以上或许是你回顾的。 modulus营运人 code>% 返回该司的其余部分。我只想把它放在另一个隐藏着这种东西的阶层。它混淆了“在磨粉中的目前时间”这一错误价值。类似:

Stopwatch stopwatch = Stopwatch.start();

// ...

int elapsed = stopwatch.elapsed();

iii

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.

Answer 2

较快的解决办法不是找到一个模块,而是简单双tw掩盖行动:

public static int currentTimeMillis() {
    return (int) (System.currentTimeMillis() & 0x00000000FFFFFFFFL);
}

Answer 3

了解到如果<代码>现时Millis <代码>上的数值滚动在<代码>x1和x2之间,请在结尾处添加<代码>x2 - x1作为负值。解决这一问题有两个途径。

Use BalusC s approach, and then when you subtract x2 - x1 check to see if it s negative. If it is, add Integer.MAX_VALUE to it again. (This assumes that no two time values will be checked that are actually more than Integer.MAX_VALUE distance apart.)
Store the current time as a a private static value when the class is first initialized. From then on, make your function return the difference between the current time and that first startup time. This assumes that these time values will not need to persist when the system is restarted, and that the system will not be alive long enough to pass the Integer.MAX_VALUE mark.

作为附带说明,我相信我们会问,你为什么不使用<条码>长期<<<>>数值?

Answer 4

你赢得了一定时间,因为你在执行方案期间可以缩短时间,把事情稍微 off倒。但是,得来的人数很多。在不了解你的问题的情况下,我不得不假设你对实际时间不感兴趣。也许你只是对过去时间重新感兴趣? 你们是否拥有一些基准? 如果时间已经过去,“巴普卢克”提出的组合解决办法就会被罚款。

Answer 5

你可以做些什么。

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

如果其负数,它就取得了一定结果,那么你会有所作为。 e.g.

int start = currentTimeMillis();

// will be positive for differences less than 24 days.
int time = currentTimeMillis() - start;

Using this approach avoid the issue of overflows as they will cancel out e.g.

int start = Integer.MAX_VALUE;
// 1 ms later
int time = Integer.MIN_VALUE /*due to overflow*/ - start; 
// time equals 1 due to underflow.

友情链接