From 1ec74da00849447fa5a6960e683de3442263c7d9 Mon Sep 17 00:00:00 2001 From: jmoore Date: Mon, 1 Jul 2019 15:37:27 +0200 Subject: [PATCH 1/2] Allow passing ExecutorService to region task --- .../java/omeis/providers/re/HSBStrategy.java | 14 ++++++- .../java/omeis/providers/re/Renderer.java | 33 ++++++++++++++++- .../omeis/providers/re/RenderingStrategy.java | 37 +++++++++++++++++-- 3 files changed, 77 insertions(+), 7 deletions(-) diff --git a/src/main/java/omeis/providers/re/HSBStrategy.java b/src/main/java/omeis/providers/re/HSBStrategy.java index 31fdab55..1128eaec 100644 --- a/src/main/java/omeis/providers/re/HSBStrategy.java +++ b/src/main/java/omeis/providers/re/HSBStrategy.java @@ -62,7 +62,18 @@ class HSBStrategy extends RenderingStrategy { /** The logger for this particular class */ private static Logger log = LoggerFactory.getLogger(HSBStrategy.class); - + + /** Shared thread pool */ + ExecutorService processor; + + public HSBStrategy(ExecutorService processor) { + this.processor = processor; + } + + public HSBStrategy(Object obj) { + this.processor = Executors.newCachedThreadPool(); + } + /** * Retrieves the maximum number of reasonable tasks to schedule based on * image size and maxTasks. @@ -329,7 +340,6 @@ private void render(RGBBuffer buf, PlaneDef planeDef) throws IOException, performanceStats.startRendering(); int n = tasks.length; Future[] rndTskFutures = new Future[n]; // [0] unused. - ExecutorService processor = Executors.newCachedThreadPool(); while (0 < --n) { rndTskFutures[n] = processor.submit(tasks[n]); diff --git a/src/main/java/omeis/providers/re/Renderer.java b/src/main/java/omeis/providers/re/Renderer.java index 12d0a71c..58c6751c 100644 --- a/src/main/java/omeis/providers/re/Renderer.java +++ b/src/main/java/omeis/providers/re/Renderer.java @@ -11,6 +11,8 @@ import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; @@ -140,6 +142,11 @@ public class Renderer { /** Lookup table provider. */ private LutProvider lutProvider; + /** + * Shared thread Pool + */ + private ExecutorService processor; + /** * Returns a copy of a list of channel bindings with one element removed; * the so called "other" channel bindings for the image. @@ -354,10 +361,32 @@ public Renderer(QuantumFactory quantumFactory, List renderingModels, Pixels pixelsObj, RenderingDef renderingDefObj, PixelBuffer bufferObj, LutProvider lutProvider) { + this(quantumFactory, renderingModels, pixelsObj, renderingDefObj, bufferObj, + lutProvider, Executors.newCachedThreadPool()); + } + + /** + * Creates a new instance to render the specified pixels set and get this + * new instance ready for rendering. + * + * @param quantumFactory a populated quantum factory. + * @param renderingModels an enumerated list of all rendering models. + * @param pixelsObj Pixels object. + * @param renderingDefObj Rendering definition object. + * @param bufferObj PixelBuffer object. + * @param lutProvider provider of the available lookup tables. + * @param processor shared thread pool + * @throws NullPointerException If null parameters are passed. + */ + public Renderer(QuantumFactory quantumFactory, + List renderingModels, Pixels pixelsObj, + RenderingDef renderingDefObj, PixelBuffer bufferObj, + LutProvider lutProvider, ExecutorService processor) { metadata = pixelsObj; rndDef = renderingDefObj; buffer = bufferObj; this.lutProvider = lutProvider; + this.processor = processor; if (metadata == null) { throw new NullPointerException("Expecting not null metadata"); } else if (rndDef == null) { @@ -396,7 +425,7 @@ public Renderer(QuantumFactory quantumFactory, } // Create an appropriate rendering strategy. - renderingStrategy = RenderingStrategy.makeNew(rndDef.getModel()); + renderingStrategy = RenderingStrategy.makeNew(rndDef.getModel(), processor); // Examine the metadata we've been given and enable optimizations. checkOptimizations(); @@ -424,7 +453,7 @@ LutProvider getLutProvider() public void setModel(RenderingModel model) { rndDef.setModel(model); - renderingStrategy = RenderingStrategy.makeNew(model); + renderingStrategy = RenderingStrategy.makeNew(model, processor); } /** diff --git a/src/main/java/omeis/providers/re/RenderingStrategy.java b/src/main/java/omeis/providers/re/RenderingStrategy.java index d9d679ef..ab11b9fc 100644 --- a/src/main/java/omeis/providers/re/RenderingStrategy.java +++ b/src/main/java/omeis/providers/re/RenderingStrategy.java @@ -8,6 +8,8 @@ package omeis.providers.re; import java.io.IOException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -70,6 +72,16 @@ abstract class RenderingStrategy { */ protected int maxTasks; + protected ExecutorService processor; + + /** + * Shared thread Pool + * + */ + public RenderingStrategy(ExecutorService processor) { + this.processor = processor; + } + /** * Checks if the passed region is valid. * @@ -209,20 +221,39 @@ protected RGBAIntBuffer getRGBAIntBuffer() * according to the model that dictates how transformed raw data is to be * mapped into a color space. This model is identified by the passed * argument. - * + * * @param model * Identifies the color space model. * @return A strategy suitable for the specified model. + * @deprecated Please use {@link #makeNew(RenderingModel, ExecutorService)}. */ + @Deprecated() static RenderingStrategy makeNew(RenderingModel model) { + ExecutorService processor = Executors.newCachedThreadPool(); + return makeNew(model, processor); + } + + /** + * Factory method to retrieve a concrete strategy. The strategy is selected + * according to the model that dictates how transformed raw data is to be + * mapped into a color space. This model is identified by the passed + * argument. + * + * @param model + * Identifies the color space model. + * @param processor + * Shared thread pool. + * @return A strategy suitable for the specified model. + */ + static RenderingStrategy makeNew(RenderingModel model, ExecutorService processor) { String value = model.getValue(); if (value.equals(Renderer.MODEL_GREYSCALE)) { return new GreyScaleStrategy(); } else if (value.equals(Renderer.MODEL_HSB)) { - return new HSBStrategy(); + return new HSBStrategy(processor); } else if (value.equals(Renderer.MODEL_RGB)) { //return new RGBStrategy(); - return new HSBStrategy(); + return new HSBStrategy(processor); } log.warn("WARNING: Unknown model '" + value + "' using greyscale."); return new GreyScaleStrategy(); From 591fa1ba9a42535578db2a1ff9f1e565d964f021 Mon Sep 17 00:00:00 2001 From: Kevin Kozlowski Date: Wed, 25 Feb 2026 16:24:21 -0500 Subject: [PATCH 2/2] Use existing ExecutorService, don't shut down shared ExecutorService --- src/main/java/omeis/providers/re/HSBStrategy.java | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/main/java/omeis/providers/re/HSBStrategy.java b/src/main/java/omeis/providers/re/HSBStrategy.java index 1128eaec..93919934 100644 --- a/src/main/java/omeis/providers/re/HSBStrategy.java +++ b/src/main/java/omeis/providers/re/HSBStrategy.java @@ -63,17 +63,10 @@ class HSBStrategy extends RenderingStrategy { /** The logger for this particular class */ private static Logger log = LoggerFactory.getLogger(HSBStrategy.class); - /** Shared thread pool */ - ExecutorService processor; - public HSBStrategy(ExecutorService processor) { this.processor = processor; } - public HSBStrategy(Object obj) { - this.processor = Executors.newCachedThreadPool(); - } - /** * Retrieves the maximum number of reasonable tasks to schedule based on * image size and maxTasks. @@ -362,9 +355,6 @@ private void render(RGBBuffer buf, PlaneDef planeDef) throws IOException, } } - // Shutdown the task processor - processor.shutdown(); - // End the performance metrics for this rendering event. performanceStats.endRendering(); }