Wait for the execution of a method to be finished, before being able to re-export it again

Question

I am developing a data synchronizer, basically the synchronizer will every 5 seconds check if there are data to be synchronized.

However, my doubt consists in how I will do for when the synchronization is happening, it does not start a new synchronization, IE, a synchronization process will have to start, finish, wait the 5 seconds to be able to start a new synchronization. Does anyone have an idea how to do?

Answer 1

If your synchronization operation involves interface updates these tasks must be performed in the FX Thread, otherwise such an error will occur: Not on FX application thread

Assuming this is the case, to perform a task every X time on the main thread we have the Scheduledservice, which works as follows:

The Scheduledservice is a Service which will Automatically Restart itself after a Successful Execution, and under some conditions will Restart Even in case of Failure. A new Scheduledservice Begins in the READY state, just as a normal Service. After Calling start or Restart, the Scheduledservice will enter the SCHEDULED state for the Duration specified by delay.

Executable example:

ScheduledService<Void> sync = new ScheduledService<Void>() {
    @Override
    protected Task<Void> createTask() {
        Task<Void> task = new Task<Void>() {
            @Override
            protected Void call() throws Exception{
                // sua operação de sincronização
                return null;
            }                
        };
        return task;
    }
};
// Thread executa a cada 5 segundos
sync.setPeriod(Duration.seconds(5));

// Início do serviço de sincronização
sync.start();

// Parar a sincronização
sync.cancel();

This way you can put a period that is equivalent to the time of execution of the update code in average + 5 seconds. There would be no need to check if the process is already occurring and to allocate a thread to count the 5 seconds.

Important remarks: If the execution of the task takes longer than the specified period the delay is skipped and the next schedule is executed immediately.