1. import java.util.*;
  2. import java.util.concurrent.*;
  3. import java.time.Instant;
  5. class TimestampMonitor {
  7. private final int maxRequestsPerWindow;
  8. private final long windowDurationMillis;
  9. private final Map<String, List<Instant>> requestTimestamps; // Key: identifier, Value: List of timestamps
  10. private final Map<String, BlockingQueue<Instant>> requestQueue; // Queue of requests for each identifier
  11. private final ExecutorService rateLimiter;
  13. public TimestampMonitor(int maxRequestsPerWindow, long windowDurationMillis) {
  14. this.maxRequestsPerWindow = maxRequestsPerWindow;
  15. this.windowDurationMillis = windowDurationMillis;
  16. this.requestTimestamps = new HashMap<>();
  17. this.requestQueue = new HashMap<>();
  18. this.rateLimiter = Executors.newFixedThreadPool(10); //Adjust thread pool size as needed
  19. }
  21. public synchronized boolean allowRequest(String identifier) {
  22. // Get the current time
  23. Instant now = Instant.now();
  25. // Get timestamps for the identifier
  26. List<Instant> timestamps = requestTimestamps.getOrDefault(identifier, new ArrayList<>());
  28. // Remove timestamps older than the window duration
  29. timestamps.removeIf(ts -> now.minusMillis(windowDurationMillis).isBefore(ts));
  31. // Check if the number of requests within the window exceeds the limit
  32. if (timestamps.size() >= maxRequestsPerWindow) {
  33. return false; // Rate limit exceeded
  34. }
  36. // Add the current timestamp to the list
  37. timestamps.add(now);
  38. requestTimestamps.put(identifier, timestamps);
  40. // Add the timestamp to the queue
  41. requestQueue.computeIfAbsent(identifier, k -> new LinkedBlockingQueue<>()).offer(now);
  44. return true; // Request allowed
  45. }
  48. public void processQueue(String identifier) {
  49. //Process requests from the queue for a given identifier
  50. BlockingQueue<Instant> queue = requestQueue.get(identifier);
  51. while (!queue.isEmpty()) {
  52. Instant timestamp = queue.poll();
  53. //Simulate processing the request with the timestamp
  54. System.out.println("Processing request from " + identifier + " at: " + timestamp);
  55. rateLimiter.submit(() -> {
  56. try {
  57. Thread.sleep(100); // Simulate processing time
  58. } catch (InterruptedException e) {
  59. Thread.currentThread().interrupt();
  60. }
  61. });
  62. }
  63. }
  65. public void shutdown() {
  66. rateLimiter.shutdown();
  67. try {
  68. rateLimiter.awaitTermination(5, TimeUnit.SECONDS);
  69. } catch (InterruptedException e) {
  70. Thread.currentThread().interrupt();
  71. }
  72. }
  73. }

Add your comment