MY own Executors class

Question

The point of this would be something like Executors.newFixedThreadPool().
Comment/suggest/criticize on it please? I just wanted to take a whack at it :p
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
public class ExecutionService {
     public static void main(String[] args) throws Exception {
          ExecutionService executor = new ExecutionService();
          Runnable test1 = new Runnable() {
               @Override
               public void run() {
                    System.out.println("Test one complete!");
          Runnable test2 = new Runnable() {
               @Override
               public void run() {
                    System.out.println("Test two complete!");
          executor.executeAndWait(test1);
          executor.executeImmediately(test2);
     public ExecutionService() {
          runnableTasks = new LinkedBlockingQueue<Runnable>(Integer.MAX_VALUE);
          final int NUM_PROCESSORS = Runtime.getRuntime().availableProcessors();
          for(int i = 0; i < NUM_PROCESSORS; i++) {
               createNewExecutor();
     public Executor createNewExecutor() {
          return new Executor(new Runnable() {
               @Override
               public void run() {
                    try {
                         for(;;) {
                              getNewTask().run();     
                    } catch(InterruptedException e) {
                         e.printStackTrace();
                    } finally {
                         createNewExecutor();
     public boolean executeImmediately(Runnable task) {
          return runnableTasks.offer(task);
     public void executeAndWait(Runnable task) throws InterruptedException {
          runnableTasks.put(task);
     public Runnable getNewTask() throws InterruptedException {
          synchronized(this) {
               return runnableTasks.take();
     private LinkedBlockingQueue<Runnable> runnableTasks;
public class Executor {
     public Executor(Runnable task) {
          Thread t = new Thread(task);
          t.setDaemon(true);
          t.start();
}Edited by: Jadz_Core on Aug 6, 2009 4:37 PM

Answer 1

Hopefully it is to satisfactory now :)
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ExecutionService {
     public static void main(String[] args) throws Exception {
          ExecutionService executor = new ExecutionService();
          Runnable test1 = new Runnable() {
               @Override
               public void run() {
                    System.out.println("Test one complete!");
          Runnable test2 = new Runnable() {
               @Override
               public void run() {
                    System.out.println("Test two complete!");
          executor.waitToExecute(test1);
          executor.executeImmediately(test2);
     public ExecutionService() {
          runnableTasks = new LinkedBlockingQueue<Runnable>(Integer.MAX_VALUE);
          initializeExecutors();
     public ExecutionService(BlockingQueue<Runnable> blockingQueue) {
          runnableTasks = blockingQueue;
          initializeExecutors();
     private final void initializeExecutors() {
          final int NUM_PROCESSORS = Runtime.getRuntime().availableProcessors();
          for(int i = 0; i < NUM_PROCESSORS; i++) {
               createNewExecutor();
               ++numThreadsRunning;
     private final Runnable getPermTask() {
          return new Runnable() {
               @Override
               public void run() {
                    Exception ex = null;
                    try {
                         while(continueRunning) {
                              getNewTask().run();     
                    } catch(InterruptedException e) {
                         (ex = e).printStackTrace();
                    } catch(Exception e) {
                         (ex = e).printStackTrace();
                    } finally {
                         if(ex != null) {
                              createNewExecutor();
     private Executor createNewExecutor() {
          return new Executor(getPermTask());
     private Runnable getNewTask() throws InterruptedException {
          return runnableTasks.take();
     public boolean executeImmediately(Runnable task) throws Exception {
          if(!continueRunning) {
               throw new Exception("ExecutorService instance is shut down");
          return runnableTasks.offer(task);
     public void waitToExecute(Runnable task) throws InterruptedException, Exception {
          if(!continueRunning) {
               throw new Exception("ExecutorService instance is shut down");
          runnableTasks.put(task);
     public void shutDown() {
          continueRunning = false;
          Runnable emptyTask = new Runnable() {
               @Override
               public void run() {
                    return;
          for(int i = 0; i < numThreadsRunning; i++) try {
               waitToExecute(emptyTask);
          } catch(InterruptedException e) {
               System.out.println("Could not shut down!");
               e.printStackTrace();
          } catch(Exception e) {
               e.printStackTrace();
     private int numThreadsRunning = 0;
     private volatile boolean continueRunning = true;
     private BlockingQueue<Runnable> runnableTasks;
class Executor {
     public Executor(Runnable task) {
          Thread t = new Thread(task);
          t.setDaemon(true);
          t.start();
}