1. import java.time.LocalTime;
  2. import java.util.concurrent.ConcurrentHashMap;
  3. import java.util.concurrent.Executors;
  4. import java.util.concurrent.ScheduledExecutorService;
  5. import java.util.concurrent.TimeUnit;
  7. public class TimeWatcher {
  9. private final ConcurrentHashMap<LocalTime, Integer> timeCounts = new ConcurrentHashMap<>(); // Store time and change count
  10. private final int rateLimit = 5; // Max changes allowed per second
  11. private final long interval = 1000; // Check interval in milliseconds (1 second)
  12. private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
  14. public void watchTimeChanges() {
  15. scheduler.scheduleAtFixedRate(this::checkTimeChanges, 0, interval, TimeUnit.MILLISECONDS);
  16. }
  18. private void checkTimeChanges() {
  19. LocalTime currentTime = LocalTime.now();
  21. // Increment count for the current time
  22. timeCounts.computeIfAbsent(currentTime, k -> 1).incrementAndGet();
  24. // Rate limiting logic
  25. if (timeCounts.get(currentTime) > rateLimit) {
  26. // Handle rate limit exceeded (e.g., log, throttle)
  27. System.out.println("Rate limit exceeded for time: " + currentTime);
  28. // Reset the count for this time to avoid continuous exceeding
  29. timeCounts.remove(currentTime);
  30. }
  31. }
  33. public static void main(String[] args) {
  34. TimeWatcher watcher = new TimeWatcher();
  35. watcher.watchTimeChanges();
  37. // Keep the main thread alive to allow the scheduler to run.
  38. try {
  39. Thread.sleep(60000); // Run for 60 seconds
  40. } catch (InterruptedException e) {
  41. e.printStackTrace();
  42. } finally {
  43. watcher.scheduler.shutdown();
  44. }
  45. }
  46. }

Add your comment