Made the necessary changes according to the reviews

Author: DivyanshIITB

lucene/core/src/java/org/apache/lucene/index/MultiTenantMergeScheduler.java

@@ -10,48 +10,50 @@
  */
 public class MultiTenantMergeScheduler extends MergeScheduler {
 
-    // Shared global thread pool with lazy initialization
-    private static class LazyHolder {
-        static final ExecutorService MERGE_THREAD_POOL = 
-            Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() / 2);
-    }
+    // Shared global thread pool
+    private static final ExecutorService MERGE_THREAD_POOL = Executors.newFixedThreadPool(
+        Runtime.getRuntime().availableProcessors() / 2
+    );
 
-    // Use getMergeThreadPool() instead of direct access
+    // Track active merges per writer
+    private final List<Future<?>> activeMerges = Collections.synchronizedList(new ArrayList<>());
 
     @Override
     public void merge(MergeScheduler.MergeSource mergeSource, MergeTrigger trigger) throws IOException {
-        while (mergeSource.hasPendingMerges()) { // Use hasPendingMerges() instead of relying on null check
+        while (true) {
             MergePolicy.OneMerge merge = mergeSource.getNextMerge();
-            if (merge == null) {
-                break; // Explicitly exit if no merge is available
-            }
+            if (merge == null) break;  // No more merges
 
-            // Submit merge task to the shared thread pool
-            MERGE_THREAD_POOL.submit(() -> {
+            // Submit merge task and track future
+            Future<?> future = MERGE_THREAD_POOL.submit(() -> {
                 try {
                     mergeSource.merge(merge);
                 } catch (IOException e) {
                     throw new RuntimeException("Merge operation failed", e);
                 }
             });
 
+            activeMerges.add(future);
+            
             // Cleanup completed merges
             activeMerges.removeIf(Future::isDone);
         }
     }
 
+    private final ConcurrentHashMap<IndexWriter, List<Merge>> activeMerges = new ConcurrentHashMap<>();
+
     @Override
     public void close() throws IOException {
-        // Wait for all running merges to complete
-        for (Future<?> future : activeMerges) {
-            try {
-                future.get();  // Wait for completion
-            } catch (Exception e) {
-                throw new IOException("Error while waiting for merges to finish", e);
-            }
+        IndexWriter currentWriter = getCurrentIndexWriter();  // Method to get the calling writer
+        List<Merge> merges = activeMerges.getOrDefault(currentWriter, Collections.emptyList());
+    
+        for (Merge merge : merges) {
+            merge.waitForCompletion(); // Only wait for merges related to this writer
         }
-        activeMerges.clear();
+    
+        activeMerges.remove(currentWriter); // Cleanup after closing
     }
+    
 
     // Providing a method to shut down the global thread pool gracefully
     public static void shutdownThreadPool() {

lucene/core/src/test/org/apache/lucene/index/TestMultiTenantMergeScheduler.java

@@ -3,9 +3,14 @@
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
+import org.apache.lucene.analysis.MockAnalyzer;
 import org.apache.lucene.document.Document;
-import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.util.LuceneTestCase;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 public class TestMultiTenantMergeScheduler extends LuceneTestCase {
 
@@ -57,17 +62,32 @@ public void testConcurrentMerging() throws Exception {
         }
         writer.commit();
 
-        long startTime = System.currentTimeMillis();
-        writer.forceMerge(1);
-        long endTime = System.currentTimeMillis();
+        CountDownLatch latch = new CountDownLatch(2);
+        ExecutorService executor = Executors.newFixedThreadPool(2);
+
+        Future<?> mergeTask1 = executor.submit(() -> {
+            latch.countDown();
+            try { latch.await(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
+            writer.forceMerge(1);
+        });
+
+        Future<?> mergeTask2 = executor.submit(() -> {
+            latch.countDown();
+            try { latch.await(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
+            writer.forceMerge(1);
+        });
+
+        mergeTask1.get();
+        mergeTask2.get();
+        executor.shutdown();
 
         writer.close();
         scheduler.close();
         MultiTenantMergeScheduler.shutdownThreadPool();
 
-        // Check if merging took less time than sequential execution would
-        assertTrue("Merges did not happen concurrently!", (endTime - startTime) < 5000);
+        // Assert that at least two merges ran concurrently
+        assertTrue("Expected concurrent merges", scheduler.getActiveMergesCount() > 1);
 
         dir.close();
     }
-}
+}