docs: public void perform(TaskRequest req, TaskResponse res) {
           final String poolAttributeName = (String) this.attributeNamePhrase.evaluate(req, res);
           final boolean useExisting = Boolean.valueOf((String) this.useExistingPhrase.evaluate(req, res));
           
           final ExecutorService executorService;
           final boolean usingExisting;
           if (useExisting && req.hasAttribute(poolAttributeName)) {
               // Try using an existing pool
               executorService = (ExecutorService) req.getAttribute(poolAttributeName);
               usingExisting = true;
           }
           else {
               //No existing pool or configured to ignore it, create a new pool
               final int threads = Integer.parseInt((String) this.threadsPhrase.evaluate(req, res));
               final int queueRatio = Integer.parseInt((String) this.queueRatioPhrase.evaluate(req, res));
               
               if (this.log.isDebugEnabled()) {
                   this.log.debug("Creating ThreadPoolExecutor with " + threads + " threads and queue space of " + (threads * queueRatio));
               }
               
               executorService = this.createExecutorService(threads, queueRatio);
  
               usingExisting = false;
           }
           
           try {
               //Provide the pool as a response attribute
               res.setAttribute(poolAttributeName, executorService);
               
               //Delegate to sub-task execution
               this.performSubtasks(req, res);
           }
           finally {
               //If using an existing pool it should not get shutdown here
               if (usingExisting) {
                   return;
               }
               
               //If shutdown already it is due to a child task, likely from a fail-fast ConcurrentTask handling an exception
               if (executorService.isShutdown()) {
                   throw new IllegalStateException("The ExecutorService was shutdown by a child task. This is likely due to an exception inside of a ConcurrentTask. Check the logs for information about the failed ConcurrentTask");
               }
               
               //Cleanly shutdown the pool
               executorService.shutdown();
               
               //Wait for all tasks to complete
               try {
                   executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
               }
               catch (InterruptedException e) {
                   this.log.warn("Interrupted while waiting for thread pool to shutdown", e);
               }
           }
       }