diff --git a/src/main/java/omeis/providers/re/HSBStrategy.java b/src/main/java/omeis/providers/re/HSBStrategy.java
index 31fdab55..93919934 100644
--- a/src/main/java/omeis/providers/re/HSBStrategy.java
+++ b/src/main/java/omeis/providers/re/HSBStrategy.java
@@ -62,7 +62,11 @@ class HSBStrategy extends RenderingStrategy {
 	
     /** The logger for this particular class */
     private static Logger log = LoggerFactory.getLogger(HSBStrategy.class);
-    
+
+    public HSBStrategy(ExecutorService processor) {
+        this.processor = processor;
+    }
+
     /**
      * Retrieves the maximum number of reasonable tasks to schedule based on
      * image size and <i>maxTasks</i>.
@@ -329,7 +333,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]);
@@ -352,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();
     }
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<RenderingModel> 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 <code>null</code> parameters are passed.
+     */
+    public Renderer(QuantumFactory quantumFactory,
+                    List<RenderingModel> 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();