Improve ThreadUtil APIs. Add image IO and Processing thread pools.

Author: nroduit

weasis-acquire/weasis-acquire-explorer/src/main/java/org/weasis/acquire/explorer/gui/control/AcquirePublishPanel.java

@@ -61,7 +61,7 @@ public class AcquirePublishPanel extends JPanel {
   private AuthMethod authMethod;
 
   public static final ExecutorService PUBLISH_DICOM =
-      ThreadUtil.buildNewSingleThreadExecutor("Publish Dicom"); // NON-NLS
+      ThreadUtil.newSingleThreadExecutor("AcquirePublishDicom");
 
   public AcquirePublishPanel() {
     publishBtn.addActionListener(

weasis-acquire/weasis-acquire-explorer/src/main/java/org/weasis/acquire/explorer/gui/control/ImportPanel.java

@@ -35,7 +35,7 @@
 public class ImportPanel extends JPanel {
 
   public static final ExecutorService IMPORT_IMAGES =
-      ThreadUtil.buildNewSingleThreadExecutor("ImportImage");
+      ThreadUtil.newSingleThreadExecutor("ImportImage");
 
   private final JButton importBtn = new JButton(Messages.getString("ImportPanel.import"));
   private final SpinnerProgress progressBar = new SpinnerProgress();

weasis-acquire/weasis-acquire-explorer/src/main/java/org/weasis/acquire/explorer/gui/dialog/AcquirePublishDialog.java

@@ -335,7 +335,9 @@ private void publishAction(File exportDir) {
     }
 
     SwingWorker<File, AcquireMediaInfo> dicomizeTask = setupPublishingTask(toPublish, exportDir);
-    ThreadUtil.buildNewSingleThreadExecutor("Dicomize").execute(dicomizeTask); // NON-NLS
+    try (var executor = ThreadUtil.newSingleThreadExecutor("AcquireDicomize")) {
+      executor.execute(dicomizeTask);
+    }
   }
 
   private SwingWorker<File, AcquireMediaInfo> setupPublishingTask(

weasis-base/weasis-base-explorer/src/main/java/org/weasis/base/explorer/JIThumbnailCache.java

@@ -40,12 +40,7 @@ public final class JIThumbnailCache {
   // ImageElement)
   private final ExecutorService qExecutor =
       new ThreadPoolExecutor(
-          1,
-          1,
-          0L,
-          TimeUnit.MILLISECONDS,
-          queue,
-          ThreadUtil.getThreadFactory("Thumbnail Cache")); // NON-NLS
+          1, 1, 0L, TimeUnit.MILLISECONDS, queue, ThreadUtil.namedThreadFactory("ThumbnailCache"));
 
   private final Map<URI, ThumbnailIcon> cachedThumbnails =
       Collections.synchronizedMap(

weasis-base/weasis-base-explorer/src/main/java/org/weasis/base/explorer/list/AThumbnailListPane.java

@@ -35,7 +35,7 @@ protected AThumbnailListPane(ThumbnailList<E> thumbList) {
         thumbList.asComponent(),
         ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
         ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-    this.pool = ThreadUtil.buildNewSingleThreadExecutor("Thumbnail List"); // NON-NLS
+    this.pool = ThreadUtil.newSingleThreadExecutor("AcquireThumbnailList");
 
     this.thumbnailList = thumbList;
     this.thumbnailList.addListSelectionListener(new JIListSelectionAdapter());

weasis-core/src/main/java/org/weasis/core/api/media/data/Thumbnail.java

@@ -57,7 +57,7 @@ public class Thumbnail extends JLabel implements Thumbnailable {
       AppProperties.buildAccessibleTempDirectory(
           AppProperties.FILE_CACHE_DIR.getName(), "thumb"); // NON-NLS
   public static final ExecutorService THUMB_LOADER =
-      ThreadUtil.buildNewSingleThreadExecutor("Thumbnail Loader"); // NON-NLS
+      ThreadUtil.newSingleThreadExecutor("ThumbnailLoader");
 
   public static final String KEY_SIZE = "explorer.thumbnail.size";
   public static final int MIN_SIZE = 48;

weasis-core/src/main/java/org/weasis/core/api/util/ThreadUtil.java

@@ -9,60 +9,245 @@
  */
 package org.weasis.core.api.util;
 
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
+import java.util.Objects;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
 
-public class ThreadUtil {
+/** Utility class for creating thread pools and thread factories with custom naming. */
+public final class ThreadUtil {
 
-  private ThreadUtil() {
-    super();
-  }
+  private ThreadUtil() {}
 
   /**
-   * Creates an Executor that uses a single worker thread operating off an unbounded queue, and uses
-   * the provided ThreadFactory to create a new thread when needed. Unlike the otherwise equivalent
-   * {@code newFixedThreadPool(1, threadFactory)} the returned executor is guaranteed not to be
-   * reconfigurable to use additional threads.
+   * Creates a single-threaded executor with named threads.
    *
-   * @param name the name of the new thread
-   * @return the newly created single-threaded Executor
-   * @throws NullPointerException if threadFactory is null
+   * @param name the name prefix for the thread
+   * @return a new single-threaded executor
+   * @throws NullPointerException if name is null
    */
-  public static ExecutorService buildNewSingleThreadExecutor(final String name) {
-    return Executors.newSingleThreadExecutor(getThreadFactory(name));
+  public static ExecutorService newSingleThreadExecutor(String name) {
+    return Executors.newSingleThreadExecutor(namedThreadFactory(name));
   }
 
   /**
-   * Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded
-   * queue, using the provided ThreadFactory to create new threads when needed. At any point, at
-   * most {@code nThreads} threads will be active processing tasks. If additional tasks are
-   * submitted when all threads are active, they will wait in the queue until a thread is available.
-   * If any thread terminates due to a failure during execution prior to shutdown, a new one will
-   * take its place if needed to execute subsequent tasks. The threads in the pool will exist until
-   * it is explicitly {@link ExecutorService#shutdown shutdown}.
+   * Creates a fixed thread pool with named threads.
    *
    * @param nThreads the number of threads in the pool
-   * @param name the name of the new thread
-   * @return the newly created thread pool
-   * @throws NullPointerException if threadFactory is null
-   * @throws IllegalArgumentException if {@code nThreads <= 0}
+   * @param name the name prefix for threads
+   * @return a new fixed thread pool
+   * @throws IllegalArgumentException if nThreads <= 0
+   * @throws NullPointerException if name is null
    */
-  public static ExecutorService buildNewFixedThreadExecutor(int nThreads, final String name) {
-    return Executors.newFixedThreadPool(nThreads, getThreadFactory(name));
+  public static ExecutorService newFixedThreadPool(int nThreads, String name) {
+    return Executors.newFixedThreadPool(nThreads, namedThreadFactory(name));
   }
 
   /**
-   * Based on the default thread factory
+   * Creates a cached thread pool with named threads.
    *
-   * @param name the name prefix of the new thread
-   * @return the factory to use when creating new threads
+   * @param name the name prefix for threads
+   * @return a new cached thread pool
+   * @throws NullPointerException if name is null
    */
-  public static ThreadFactory getThreadFactory(String name) {
-    return r -> {
-      Thread t = Executors.defaultThreadFactory().newThread(r);
-      t.setName(name + "-" + t.getName());
-      return t;
+  public static ExecutorService newCachedThreadPool(String name) {
+    return Executors.newCachedThreadPool(namedThreadFactory(name));
+  }
+
+  /**
+   * Creates an IO-optimized bounded thread pool for image loading operations. Pool size and queue
+   * capacity are calculated based on system resources.
+   *
+   * @param name the name prefix for threads
+   * @return a new IO-optimized thread pool
+   * @throws NullPointerException if name is null
+   */
+  public static ExecutorService newImageIOThreadPool(String name) {
+    var config = calculateIOPoolConfig();
+
+    return new ThreadPoolExecutor(
+        config.poolSize(),
+        config.poolSize(),
+        30L,
+        TimeUnit.SECONDS,
+        new LinkedBlockingQueue<>(config.queueCapacity()),
+        namedDaemonThreadFactory(name, true),
+        new ThreadPoolExecutor.CallerRunsPolicy());
+  }
+
+  /**
+   * Creates a bounded thread pool optimized for CPU-intensive image processing. Pool size and queue
+   * capacity are calculated based on system resources.
+   *
+   * @param name the name prefix for threads
+   * @return a new image processing thread pool
+   * @throws NullPointerException if name is null
+   */
+  public static ExecutorService newImageProcessingThreadPool(String name) {
+    var config = calculateProcessingPoolConfig();
+
+    return new ThreadPoolExecutor(
+        config.poolSize(),
+        config.poolSize(),
+        30L,
+        TimeUnit.SECONDS,
+        new LinkedBlockingQueue<>(config.queueCapacity()),
+        namedDaemonThreadFactory(name, true),
+        new ThreadPoolExecutor.CallerRunsPolicy());
+  }
+
+  // Calculates optimal IO pool configuration based on system resources
+  private static PoolConfig calculateIOPoolConfig() {
+    int cores = Runtime.getRuntime().availableProcessors();
+    long totalMemoryMB = Runtime.getRuntime().maxMemory() / (1024 * 1024);
+
+    // IO operations benefit from more threads due to blocking nature
+    // Scale with cores but cap based on memory to avoid resource exhaustion
+    int poolSize = Math.max(2, Math.min(calculateMaxIOThreads(totalMemoryMB), cores * 2));
+
+    // Queue capacity scales with available memory and pool size
+    // Each queued task represents potential memory usage
+    int queueCapacity = calculateIOQueueCapacity(totalMemoryMB, poolSize);
+
+    return new PoolConfig(poolSize, queueCapacity);
+  }
+
+  // Calculates optimal processing pool configuration based on system resources
+  private static PoolConfig calculateProcessingPoolConfig() {
+    int cores = Runtime.getRuntime().availableProcessors();
+    long totalMemoryMB = Runtime.getRuntime().maxMemory() / (1024 * 1024);
+
+    // CPU-intensive tasks: optimal pool size close to core count
+    // Add one extra thread to handle coordination and avoid starvation
+    int poolSize = Math.max(1, Math.min(cores + 1, calculateMaxProcessingThreads(totalMemoryMB)));
+
+    // Processing tasks typically require more memory per task
+    // Conservative queue to prevent memory pressure
+    int queueCapacity = calculateProcessingQueueCapacity(totalMemoryMB, poolSize);
+
+    return new PoolConfig(poolSize, queueCapacity);
+  }
+
+  // Calculate maximum IO threads based on available memory
+  private static int calculateMaxIOThreads(long totalMemoryMB) {
+    // Rough estimation: each IO thread might use ~100MB for buffers and caching
+    return Math.max(2, Math.min(16, (int) (totalMemoryMB / 100)));
+  }
+
+  // Calculate maximum processing threads based on available memory
+  private static int calculateMaxProcessingThreads(long totalMemoryMB) {
+    // Processing threads need more memory for image data (~300MB per thread)
+    return Math.max(1, Math.min(12, (int) (totalMemoryMB / 300)));
+  }
+
+  // Calculate IO queue capacity based on memory and pool size
+  private static int calculateIOQueueCapacity(long totalMemoryMB, int poolSize) {
+    // Base capacity scales with memory, but consider pool size for balance
+    int baseCapacity = (int) Math.min(128, totalMemoryMB / 32);
+    // Ensure reasonable ratio between queue and pool (4:1 to 8:1)
+    return Math.max(poolSize * 4, Math.min(poolSize * 8, baseCapacity));
+  }
+
+  // Calculate processing queue capacity based on memory and pool size
+  private static int calculateProcessingQueueCapacity(long totalMemoryMB, int poolSize) {
+    // More conservative for processing tasks due to higher memory usage
+    int baseCapacity = (int) Math.min(64, totalMemoryMB / 64);
+    // Lower ratio for processing tasks (2:1 to 4:1)
+    return Math.max(poolSize * 2, Math.min(poolSize * 4, baseCapacity));
+  }
+
+  // Configuration record for pool parameters
+  private record PoolConfig(int poolSize, int queueCapacity) {}
+
+  /**
+   * Creates a thread factory that names threads with the given prefix.
+   *
+   * @param name the name prefix for threads
+   * @return a thread factory with custom naming
+   * @throws NullPointerException if name is null
+   */
+  public static ThreadFactory namedThreadFactory(String name) {
+    return namedDaemonThreadFactory(name, false);
+  }
+
+  /**
+   * Creates a thread factory that names threads with the given prefix and daemon status.
+   *
+   * @param name the name prefix for threads
+   * @param daemon whether threads should be daemon threads
+   * @return a thread factory with custom naming and daemon status
+   * @throws NullPointerException if name is null
+   */
+  public static ThreadFactory namedDaemonThreadFactory(String name, boolean daemon) {
+    Objects.requireNonNull(name, "Thread name cannot be null");
+    var threadCounter = new AtomicInteger(1);
+    return runnable -> {
+      var thread = Executors.defaultThreadFactory().newThread(runnable);
+      thread.setName(name + "-" + threadCounter.getAndIncrement());
+      thread.setDaemon(daemon);
+      return thread;
     };
   }
+
+  /**
+   * Creates a single-threaded executor with daemon threads.
+   *
+   * @param name the name prefix for the thread
+   * @return a new single-threaded executor with daemon threads
+   */
+  public static ExecutorService newSingleThreadDaemonExecutor(String name) {
+    return Executors.newSingleThreadExecutor(namedDaemonThreadFactory(name, true));
+  }
+
+  /**
+   * Creates a fixed thread pool with daemon threads.
+   *
+   * @param nThreads the number of threads in the pool
+   * @param name the name prefix for threads
+   * @return a new fixed thread pool with daemon threads
+   */
+  public static ExecutorService newFixedDaemonThreadPool(int nThreads, String name) {
+    return Executors.newFixedThreadPool(nThreads, namedDaemonThreadFactory(name, true));
+  }
+
+  // Creates a shutdown hook for graceful executor shutdown
+  private static Thread createShutdownHook(
+      ExecutorService executor, String name, long timeoutSeconds) {
+    return new Thread(
+        () -> {
+          executor.shutdown();
+          try {
+            if (!executor.awaitTermination(timeoutSeconds, TimeUnit.SECONDS)) {
+              executor.shutdownNow();
+            }
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            executor.shutdownNow();
+          }
+        },
+        name + "-shutdown");
+  }
+
+  /**
+   * Creates an IO thread pool with automatic shutdown hook registration.
+   *
+   * @param name the name prefix for threads
+   * @return a new IO thread pool with shutdown hook
+   */
+  public static ExecutorService newManagedImageIOThreadPool(String name) {
+    var executor = newImageIOThreadPool(name);
+    Runtime.getRuntime().addShutdownHook(createShutdownHook(executor, name, 5));
+    return executor;
+  }
+
+  /**
+   * Creates an image processing thread pool with automatic shutdown hook registration.
+   *
+   * @param name the name prefix for threads
+   * @return a new processing thread pool with shutdown hook
+   */
+  public static ExecutorService newManagedImageProcessingThreadPool(String name) {
+    var executor = newImageProcessingThreadPool(name);
+    Runtime.getRuntime().addShutdownHook(createShutdownHook(executor, name, 10));
+    return executor;
+  }
 }

weasis-dicom/weasis-dicom-explorer/src/main/java/org/weasis/dicom/explorer/DicomModel.java

@@ -133,7 +133,7 @@ public class DicomModel implements TreeModel, DataExplorerModel {
           TagW.SubseriesInstanceUID,
           new TagView(TagD.getTagFromIDs(Tag.SeriesDescription, Tag.SeriesNumber, Tag.SeriesTime)));
   public static final ExecutorService LOADING_EXECUTOR =
-      ThreadUtil.buildNewSingleThreadExecutor("Dicom Model"); // NON-NLS
+      ThreadUtil.newSingleThreadExecutor("DicomModelLoader");
 
   private static final List<TreeModelNode> modelStructure =
       Arrays.asList(TreeModelNode.ROOT, patient, study, series);

weasis-dicom/weasis-dicom-explorer/src/main/java/org/weasis/dicom/explorer/ExportDicomView.java

@@ -47,8 +47,7 @@ public class ExportDicomView extends AbstractItemDialogPage implements ExportDic
   protected final File exportDir;
   protected final DicomModel dicomModel;
   protected final ExportTree exportTree;
-  protected final ExecutorService executor =
-      ThreadUtil.buildNewFixedThreadExecutor(3, "Dicom Send task"); // NON-NLS
+  protected final ExecutorService executor = ThreadUtil.newFixedThreadPool(3, "DicomSend");
 
   public ExportDicomView(
       String title, int position, DicomModel dicomModel, CheckTreeModel treeModel) {

weasis-dicom/weasis-dicom-explorer/src/main/java/org/weasis/dicom/explorer/wado/DownloadManager.java

@@ -121,7 +121,7 @@ public class DownloadManager {
           0L,
           TimeUnit.MILLISECONDS,
           PRIORITY_QUEUE,
-          ThreadUtil.getThreadFactory("Series Downloader")); // NON-NLS
+          ThreadUtil.namedThreadFactory("SeriesDownloader"));
 
   public static class PriorityTaskComparator implements Comparator<Runnable> {