How to write a Java sequence generator for UniqueId, which will Auto-Reset to '1' (base seq. number) at midnight everyday

Question

We have a Spring boot service where we receive files everyday, because of some issue (on producer) we are receiving multiple files with same name & date appended. The new file overwriting the old, to handle it we want to append a sequence (starting from 1) at every file name. But sequence should be auto-reset to '1' at midnight everyday.

Can anybody suggest a API or a way to reset the sequence.

To generate auto sequence, we are using AtomicSequenceGenerator , but we are unable to implement a simple auto-reset logic.

public class AtomicSequenceGenerator implements SequenceGenerator {

    private AtomicLong value = new AtomicLong(1);

    @Override
    public long getNext() {
        return value.getAndIncrement();
    }
}

Answer 1

To not receive twice a 1:

public class AtomicSequenceGenerator implements SequenceGenerator {

    private AtomicLong value = new AtomicLong(1);
    private volatile LocalDate lastDate = LocalDate.now();

    @Override
    public long getNext() {
        LocalDate today = LocalDate.now();
        if (!today.equals(lastDate)) {
            synchronized(this) {
                if (!today.equals(lastDate)) {
                    lastDate = today;
                    value.set(1);
                }
            }
        }
        return value.getAndIncrement();
    }
}

That is a bit ugly, so try a single counter:

public class AtomicSequenceGenerator implements SequenceGenerator {

    private static long countWithDate(long count, LocalDate date) {
        return (((long)date.getDayOfYear()) << (63L-9)) | count;
    }

    private static long countPart(long datedCount) {
        return datedCount & ((1L << (63L-9)) - 1);
    }

    private static boolean dateChanged(long datedCount, LocalDate date) {
         return (int)(datedCount >>> (63L-9)) != date.getDayOfYear();
    }

    private AtomicLong value = new AtomicLong(countWithDate(1, LocalDate.now()));

    @Override
    public long getNext() {
        long datedCount = value.getAndIncrement();
        LocalDate today = LocalDate.now();
        if (dateChanged(dateCount, today)) {
            long next = countWithDate(1L, today);
            if (value.compareAndSet(datedCount+1, next)) {
                datedCount = next;
            } else {
                datedCount = getNext();
            }
        }
        return datedCount;
    }
}

This uses an AtomicLong with the day-of-year packed into the counter.

• One pulls a next counter.
• If the date changed then:
• when one could set the next day's 1, then give it.
• when not, someone earlier with probably an earlier counter took the 1, and then we need to take the next again.

Answer 2

You could create a singleton instance of your generator which resets itself as soon as a new date is passed.

Something like this:

public class AtomicSequenceGenerator implements SequenceGenerator {

    // Private constructor in order to avoid the creation of an instance from outside the class
    private AtomicSequenceGenerator(){}

    private AtomicLong value = new AtomicLong(1);

    @Override
    public long getNext() {
        return value.getAndIncrement();
    }

// This is where the fun starts
// The T indicates some type that represents the file date
    private static T prev_file_date = null;
    private static AtomicSequenceGenerator instance = new AtomicSequenceGenerator();

    public static synchronized long getNext(T file_date)
    {
      if ((prev_file_date == null) || (!prev_file_date.equals(file_date)))
      {
        instance.value.set(1);
        prev_file_date = file_date;
      }
      return (instance.getNext());
    }
}

Answer 3

As requested by @JoopEggen my version of his first solution :

public class AtomicSequenceGenerator implements SequenceGenerator {

    private final Clock clock;
    private final Object lock = new Object();

    @GuardedBy("lock")
    private long value;
    @GuardedBy("lock")
    private LocalDate today;

    public AtomicSequenceGenerator(Clock clock) {
        this.clock = clock;
        synchronized (lock) {
            value = 1;
            today = LocalDate.now(clock);
        }
    }

    @Override
    public long getNext() {
        synchronized (lock) {
            LocalDate date = LocalDate.now(clock);
            if (!date.equals(today)) {
                today = date;
                value = 1;
            }
            return value++;
        }
    }
}

The main differences are :

• This uses just a private monitor to protect both the LocalDate and the value.
• value is now a plain long, since it's guarded by a lock, it doesn't need to be AtomicLong anymore.
• I inject a Clock object (for easier testing)
• No double checked locking. Arguably double checked locking can be faster, but I don't know if it's really needed, until you do some performance testing.