PowerMsg3 Local Server Scheduler: Optimizing `scheduleWithFixDelay` for Multi-threaded Environments

This code snippet, part of the PowerMsg3 Local Server Scheduler, is designed for scheduling tasks in a multi-threaded environment. However, a potential issue lies in the scheduleWithFixDelay method, specifically in the usage of timerKey2Timeouts.compute. While ConcurrentHashMap is thread-safe, the compute method's behavior in the context of concurrent execution can lead to unintended consequences.

The problem arises when the BiFunction passed to compute is invoked with a key that doesn't exist in the timerKey2Timeouts map. Multiple threads might simultaneously try to create and insert a new Timeout instance for that key, potentially resulting in overwritten entries and ultimately impacting the cancellation or execution of some scheduled tasks.

The recommended solution is to replace compute with the put method. The put method is atomic, guaranteeing that only one thread succeeds in inserting the Timeout into the map, even if multiple threads attempt it concurrently. This ensures that each Timeout is correctly associated with its corresponding timer key, preventing data races and maintaining the integrity of the scheduling mechanism.

Here's a revised snippet incorporating the suggested change:

public void scheduleWithFixDelay(@NonNull final Object timerKey,
                                     @NonNull final Duration initialDelay,
                                     @NonNull final Duration delay,
                                     @NonNull final Runnable runnable,
                                     @NonNull final Context context) {
    tryCancel(timerKey2Timeouts.get(timerKey)); // Cancel existing Timeout for the key
    timerKey2Timeouts.put(timerKey, scheduleWithTimerKey(initialDelay.toNanos(),
        new ScheduledTimerTask(timerKey, delay.toNanos(), true, runnable, context)));
}

By switching to put, we enhance the thread safety of the scheduleWithFixDelay method, ensuring that task scheduling is consistent and reliable in a high-concurrency environment.