Generate monotonically increasing integers

Question

I need to generate monotonically increasing integers.

Could I use the timestamp to somehow generate such type of integer sequence?

I would request an integer at a time, and I won't be requesting more than an integer in the same second's interval - if I do, I won't mind if it passes me the same integer within that second's interval.

Ok, I'll ask: why not start a counter at zero, and count up, perhaps in some static member of a singleton class? — phs, Jan 16 '12 at 05:58
By "integer", do you mean 32-bit, or is it OK to be a 64-bit integer? — Bohemian, Jan 16 '12 at 06:02
@phs: yes may be but (sorry, for the incomplete info.) I would also need to store that in DB so that if my webapp server is restarted then last value could be restored — Rajat Gupta, Jan 16 '12 at 06:03
you need not use time. even y=x^3 is a monotonic function. There are many others. — John Eipe, Jan 16 '12 at 06:13
@JustinDanielson: I don't mind as per my requirements to start later than epoch, would it be recommended ? — Rajat Gupta, Jan 16 '12 at 06:15
It's hack, but you could store System.currentTimeMillis() in a text file, then open the file, store the number X and then do System.currentTimeMillis() - X. That'll give you the time in milliseconds since X. — JustinDanielson, Jan 16 '12 at 06:42

score 4 · Answer 1 · answered Jan 16 '12 at 06:06

4

You can use an AtomicInteger object to maintain a thread safe counter. Then use getAndIncrement() when you need the next integer.

answered Jan 16 '12 at 06:06

Dev

11,919
3
40
53

score 1 · Answer 2 · answered Jan 16 '12 at 07:01

1

Since monotonically increasing integers do not need to be contiguous (ie there can be gaps, as long as the number keeps increasing), and it sounds like you want all calls made in the same second to return the same integer, a method that returns how many seconds the JVM has been up would do nicely.

Here's a simple implementation that does that:

private static long startTime = System.currentTimeMillis();

public static int secondsSinceStart() {
    return (int) TimeUnit.SECONDS.convert(
        System.currentTimeMillis() - startTime, TimeUnit.MILLISECONDS);
}

FYI, this would last 68 years before rolling over.

answered Jan 16 '12 at 07:01

Bohemian

412,405
93
575
722

thanks so much @Bohemian! Inspired from suggestions from you all, I was thinking why not simply divide the milliseconds(since JVM is up) by 1000 to get the seconds `(System.currentTimeMillis()-startTime)/1000` which would then fall in integer range. And then instead of dividing by 1000, I could approximate with fast division by 1024 by bit shifting 10 bits to right. `(System.currentTimeMillis()-startTime)>>10`. Just asking for the sake of performance.. – Rajat Gupta Jan 17 '12 at 06:02
1

Actually, my code *does* just divide by 1000, but the above is the way of converting from milliseconds to seconds using the API. You could replace it with division by 1000, but I thought this looked prettier. As for performance, this method returns in about 60 nanoseconds running on my macbook - I'd say that's fast enough for most applications. – Bohemian Jan 17 '12 at 07:36
yes it prettier ofcourse but in terms of performance I think bit shift by 10 bits(that would result in division by 1024) would give better performance than division by 1000, perhaps !? – Rajat Gupta Jan 17 '12 at 07:40

rloeffel · Answer 3 · 2019-10-24T06:32:23.777

This is my self made generator...

  public final class IdGenerator {

  private static final int MAGNITUDE = 10000;
  private static long previousTimestamp;

  private static int counter = 0;

  private IdGenerator() {
  }

  public synchronized static long generateId() {
    final long timeMillis = System.currentTimeMillis();
    if (previousTimestamp != timeMillis) {
      counter = 0;
    }
    previousTimestamp = timeMillis;

    final int counterValue = counter++;
    if (counterValue >= MAGNITUDE) {
      //just to be sure
      throw new IllegalStateException("too many id generated for a single timestamp!");
    }

    return timeMillis * MAGNITUDE + counterValue;
  }

}

Generate monotonically increasing integers

3 Answers3

Linked