Share mapping executor across reactions; name threads for profiling

Replace per-call newFixedThreadPool with a single static pool (2–3
threads, daemon). Avoids repeated thread creation/teardown overhead
in batch processing. Each call still gets its own CompletionService
so concurrent invocations cannot observe each other's results.

Author: asad

src/main/java/com/bioinceptionlabs/reactionblast/mapping/CallableAtomMappingTool.java

@@ -30,7 +30,7 @@
 import java.util.concurrent.ExecutorCompletionService;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.ThreadFactory;
 
 import org.openscience.cdk.graph.Cycles;
 import org.openscience.cdk.interfaces.IAtom;
@@ -59,6 +59,10 @@ public class CallableAtomMappingTool implements Serializable {
     private final static ILoggingTool LOGGER
             = createLoggingTool(CallableAtomMappingTool.class);
     private static final long serialVersionUID = 0x29e2adb1716b13eL;
+    private static final int MAPPING_PARALLELISM
+            = Math.max(2, Math.min(3, Runtime.getRuntime().availableProcessors()));
+    private static final ExecutorService MAPPING_EXECUTOR
+            = Executors.newFixedThreadPool(MAPPING_PARALLELISM, new MappingThreadFactory());
 
     private Map<IMappingAlgorithm, Reactor> solution = null;
 
@@ -180,9 +184,8 @@ private void generateAtomAtomMapping(
             remaining = new IMappingAlgorithm[]{MIN, MAX, RINGS};
         }
 
-        ExecutorService executor = Executors.newFixedThreadPool(remaining.length);
         try {
-            CompletionService<Reactor> cs = new ExecutorCompletionService<>(executor);
+            CompletionService<Reactor> cs = new ExecutorCompletionService<>(MAPPING_EXECUTOR);
             int jobCounter = 0;
             for (IMappingAlgorithm algo : remaining) {
                 LOGGER.debug("Submitting " + algo.description());
@@ -194,8 +197,6 @@ private void generateAtomAtomMapping(
                 Reactor chosen = cs.take().get();
                 putSolution(chosen.getAlgorithm(), chosen);
             }
-            executor.shutdown();
-            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
             LOGGER.debug("======DONE CallableAtomMappingTool=======");
         } catch (InterruptedException | ExecutionException e) {
             LOGGER.debug("ERROR: in AtomMappingTool: " + e.getMessage());
@@ -206,7 +207,6 @@ private void generateAtomAtomMapping(
                         standardizedReaction.getID(),
                         currentTimeMillis() - mappingStart);
             }
-            executor.shutdown();
             LOGGER.debug("!!!!Atom-Atom Mapping Done!!!!");
             ThreadSafeCache.getInstance().cleanup();
         }
@@ -401,4 +401,14 @@ public Reactor call() throws Exception {
         }
     }
 
+    private static final class MappingThreadFactory implements ThreadFactory {
+
+        @Override
+        public Thread newThread(Runnable runnable) {
+            Thread thread = new Thread(runnable, "rdt-mapping");
+            thread.setDaemon(true);
+            return thread;
+        }
+    }
+
 }