1. import java.util.concurrent.*;
  2. import java.util.concurrent.atomic.AtomicInteger;
  4. public class HtmlMaintenanceQueue {
  6. private final BlockingQueue<String> taskQueue; // Queue for HTML document paths
  7. private final RateLimiter rateLimiter; // Rate limiter for task execution
  8. private final AtomicInteger taskCount = new AtomicInteger(0); //Counter for tasks
  10. public HtmlMaintenanceQueue(int maxRequestsPerSecond) {
  11. this.taskQueue = new LinkedBlockingQueue<>();
  12. this.rateLimiter = new TokenBucketRateLimiter(maxRequestsPerSecond);
  13. }
  15. public synchronized void enqueueTask(String htmlDocumentPath) throws InterruptedException {
  16. // Acquire a token from the rate limiter
  17. rateLimiter.acquire();
  19. // Add the task to the queue
  20. taskQueue.offer(htmlDocumentPath);
  22. System.out.println("Task enqueued: " + htmlDocumentPath);
  23. }
  25. public void processTasks() {
  26. ExecutorService executor = Executors.newFixedThreadPool(1); //Single thread for processing
  27. try {
  28. while (true) {
  29. String htmlDocumentPath = taskQueue.take(); // Get task from the queue
  30. System.out.println("Processing task: " + htmlDocumentPath);
  32. // Simulate maintenance task execution
  33. try {
  34. Thread.sleep(1000); // Simulate processing time
  35. } catch (InterruptedException e) {
  36. Thread.currentThread().interrupt();
  37. }
  39. System.out.println("Task completed: " + htmlDocumentPath);
  40. }
  41. } finally {
  42. executor.shutdown();
  43. }
  44. }
  46. public static void main(String[] args) throws InterruptedException {
  47. int maxRequestsPerSecond = 5; //Limit the rate of requests
  48. HtmlMaintenanceQueue queue = new HtmlMaintenanceQueue(maxRequestsPerSecond);
  50. // Simulate enqueueing tasks
  51. for (int i = 1; i <= 10; i++) {
  52. queue.enqueueTask("html/" + i + ".html");
  53. Thread.sleep(200); //Simulate task arrival rate
  54. }
  56. // Start processing tasks
  57. ExecutorService executor = Executors.newSingleThreadExecutor();
  58. executor.submit(() -> {
  59. queue.processTasks();
  60. });
  62. executor.shutdown();
  63. executor.awaitTermination(10, TimeUnit.SECONDS);
  64. }
  66. //Simple Token Bucket implementation
  67. static class TokenBucketRateLimiter {
  68. private final int capacity;
  69. private final long refillRate;
  70. private long tokens;
  71. private final ScheduledExecutorService refiller;
  73. public TokenBucketRateLimiter(int capacity) {
  74. this.capacity = capacity;
  75. this.tokens = capacity;
  76. this.refiller = Executors.newScheduledThreadPool(1);
  77. refiller.scheduleAtFixedRate(this::refill, 0, 1000, TimeUnit.MILLISECONDS); //Refill every 1 second
  78. }
  80. public synchronized void acquire() throws InterruptedException {
  81. while (tokens <= 0) {
  82. wait(); //Wait until a token is available
  83. }
  84. tokens--;
  85. }
  87. private void refill() {
  88. synchronized (this) {
  89. tokens = Math.min(capacity, tokens + (capacity / 1000)); //Refill at capacity/refillRate
  90. }
  91. }
  92. }
  93. }

Add your comment