What are disadvantages of using ThreadPoolExecutor as queue?

Question

For conventional Producer-Consumer problem, we can use ExecutorService as queue. What are disadvantages of it? Is it less efficient? Because creation of thread is costly.

executor = Executors.newFixedThreadPool(90);
// This will be called many times concurrently
public void processObjectsWithFixedSetOfThreads(Foo objectToProcess) {
   //Create a new thread and submit (executor is of fixed size hence extra tasks will be queued)
   executor.submit(new ObjectProcessorWorker(objectToProcess));
}

class ObjectProcessorWorker implements Runnable() {
  public ObjectProcessorWorker(Foo obj) {
     this.obj = obj;
  }

  public void run() {
     longRunningProcess(obj);
  }

}

Why BlockingQueue is recommended for Producer-Consumer problem however it can be done without that too (As shown above)?

EDIT

Many people are not getting the difference because ThreadPoolExecutor internally maintains the BlockingQueue.

In a biscuit factory there is a task of wrapping biscuits. If I am its owner I have two ways to speed up wrapping task.

1. Put biscuits and wrapper on assembly line have 10 workers doing work of wrapping.

   I -> queue.put(biscuits, wrapper)

   Worker -> queue.take()

2. Creating a task of wrapping biscuits putting it on a assembly line, and let the 10 workers do that.

   I -> new Task(biscuits, wrapper)

   Worker -> task = queue.take(); do(task);

I am asking the disadvantages of the later one.

Answer 1

Whenever you define ThreadPoolExecutore.. as shown bellow

ExecutorService threadPoolExecutor =
        new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>()
                );

If less than corePoolSize threads are created in the the thread pool when a task is delegated to the thread pool, then a new thread is created, even if idle threads exist in the pool.

If the internal queue of tasks is full, and corePoolSize threads or more are running, but less than maximumPoolSize threads are running, then a new thread is created to execute the task

Now if you have defined blocking queue... than after corePoolSize , it will add new threads in to queue... till the capacity of queue reached. And after overflowing queue, it will generate new threads upto maximumPoolSize.

Don't know what is dis advantage of using ExecutorService as queue. I dont think there is any disadvantages.

Answer 2

When you create a ThreadPoolExecutor using Executors.newFixedThreadPool(int), you are creating a BlockingQueue:

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

As such, you're not doing it "without" a blocking queue if you a thread pool created in this way; it's just hidden from you.