Waiting all threads in a fixed thread pool

Hello, may I know how can I wait for all the threads in a fixed thread pool to be completed, without calling shutdownNow?
Executor pool = Executors.newFixedThreadPool(nThreads);
for(int i = 0; i < 10000; i++)
pool.execute(new StockHistoryRunnable(code));
// blah blah blah
// I would like to wait for all the 10000 task to be completed. There is a method named
// awaitTermination. However, in order to use the method, I have to first call shutdownNow.
// I do not want to do so, because I need to re-use the pool later.
//

You could retrieve all the "Future" instances returned by calling "submit" on your Executor and then have a Thread sequentially wait for the completion of all these individual tasks by using "get". Of course, this will require some synchronization if it is possible that new tasks get queued while you are already waiting for the original ones to be completed. But this way you can easily find out when all tasks have completed.

Similar Messages

Strange behaviour with Fixed thread pool

Hi all
I am trying to learn multithreading. I have written a small snippet of code. After running for around 30 minutes, this code ends up in a deadlock. I am trying to figure out a reason. any help will be really appreciated. Thanks. Following is the code. I am using Ubuntu 10.04 and jdk 1.6.
package rollerdemo;
//Simulate a roller coaster, as in exercise 3.5 of Magee and Kramer.
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//This thread deals with the passengers arriving at random intervals.
class TurnstileBarrier implements Runnable
     private ControlBarrier controlBarrier;
     private CyclicBarrier cyclicBarrier;
     TurnstileBarrier(ControlBarrier controlBarrier, CyclicBarrier cyclicBarrier) {
          this.controlBarrier = controlBarrier;
          this.cyclicBarrier = cyclicBarrier;
     public void run(){
          try {
               controlBarrier.welcomePassenger();
               cyclicBarrier.await();
          } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
          } catch (BrokenBarrierException e) {
               Thread.currentThread().interrupt();
          } finally {
class RollerBarrier
     public static int NUMBER_OF_PASSENGERS_PER_CAR = 20;
     public static void main(String[] args) throws InterruptedException
          final ControlBarrier controlBarrier = new ControlBarrier();
          Runnable carBarrier = new Runnable() {
               public void run(){
                    controlBarrier.departCar();
          CyclicBarrier barrier = new CyclicBarrier(NUMBER_OF_PASSENGERS_PER_CAR, carBarrier);
          ExecutorService pool = Executors.newFixedThreadPool(NUMBER_OF_PASSENGERS_PER_CAR);
          while(true)
               pool.execute(new TurnstileBarrier(controlBarrier,barrier));
// The Control class represents the state of the controller, and the actions
// which can be performed.
class ControlBarrier
     private long queued = 0;
     private long carsSent = 0;
     private long numberOfPassengersTravelledToday = 0;
     ControlBarrier()
          queued = 0;
          carsSent = 0;
          numberOfPassengersTravelledToday = 0;
     synchronized void welcomePassenger() {
          System.out.format("Welcoming Passenger %d%n", ++queued);
          ++numberOfPassengersTravelledToday;
     synchronized void departCar() {
          queued = queued - RollerBarrier.NUMBER_OF_PASSENGERS_PER_CAR;
          System.out.format("The car %d is going now and the number of passengers travelled so far with us is %d%n", ++carsSent, numberOfPassengersTravelledToday);
}Edited by: 858236 on May 12, 2011 2:35 AM

Thanks every one for the replies. Really very helpful. After doing the stack -l pid I have got into a confusion. It seems that there is no deadlock but why would all of a sudden the program stop to run. May be I am missing some thing. Just check the stack trace. What I read is that out of 20 threads, 3 threads are waiting on the cyclic barrier await function, while other 17 are waiting to get new tasks from the pool. Am I wrong here? Many thanks.
2011-05-11 23:42:26
Full thread dump OpenJDK Client VM (19.0-b09 mixed mode, sharing):
"Attach Listener" daemon prio=10 tid=0x088fc000 nid=0x34d4 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE
   Locked ownable synchronizers:
     - None
"DestroyJavaVM" prio=10 tid=0xb4f21c00 nid=0x2c85 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE
   Locked ownable synchronizers:
     - None
"pool-1-thread-20" prio=10 tid=0xb4f20000 nid=0x2ca0 waiting on condition [0xb49ee000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-19" prio=10 tid=0xb4f1e800 nid=0x2c9f waiting on condition [0xb4a3f000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-18" prio=10 tid=0xb4f1d000 nid=0x2c9e waiting on condition [0xb4a90000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-17" prio=10 tid=0xb4f1b800 nid=0x2c9d waiting on condition [0xb4ae1000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-16" prio=10 tid=0xb4f19c00 nid=0x2c9c waiting on condition [0xb4b32000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-15" prio=10 tid=0xb4f18400 nid=0x2c9b waiting on condition [0xb4b83000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-14" prio=10 tid=0xb4f16c00 nid=0x2c9a waiting on condition [0xb4bd4000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-13" prio=10 tid=0xb4f15400 nid=0x2c99 waiting on condition [0xb4c25000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-12" prio=10 tid=0xb4f13c00 nid=0x2c98 waiting on condition [0xb4c76000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-11" prio=10 tid=0xb4f12400 nid=0x2c97 waiting on condition [0xb4cc7000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-10" prio=10 tid=0xb4f10c00 nid=0x2c96 waiting on condition [0xb4d18000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-9" prio=10 tid=0xb4f0f400 nid=0x2c95 waiting on condition [0xb4d69000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-8" prio=10 tid=0xb4f0dc00 nid=0x2c94 waiting on condition [0xb4dba000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a380108> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:227)
     at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)
     at rollerdemo.TurnstileBarrier.run(RollerBarrier.java:25)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - <0x7a3808d8> (a java.util.concurrent.ThreadPoolExecutor$Worker)
"pool-1-thread-7" prio=10 tid=0xb4f0c800 nid=0x2c93 waiting on condition [0xb4e0b000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-6" prio=10 tid=0xb4f0b400 nid=0x2c92 waiting on condition [0xb4e5c000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-5" prio=10 tid=0xb4f09800 nid=0x2c91 waiting on condition [0xb4ead000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-4" prio=10 tid=0xb4f08400 nid=0x2c90 waiting on condition [0xb4efe000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a380108> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:227)
     at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)
     at rollerdemo.TurnstileBarrier.run(RollerBarrier.java:25)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - <0x7a382cd0> (a java.util.concurrent.ThreadPoolExecutor$Worker)
"pool-1-thread-3" prio=10 tid=0xb4f07000 nid=0x2c8f waiting on condition [0xb5053000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"pool-1-thread-2" prio=10 tid=0xb4f05800 nid=0x2c8e waiting on condition [0xb50a4000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a380108> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:227)
     at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:355)
     at rollerdemo.TurnstileBarrier.run(RollerBarrier.java:25)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1110)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - <0x7a382e00> (a java.util.concurrent.ThreadPoolExecutor$Worker)
"pool-1-thread-1" prio=10 tid=0xb4f04800 nid=0x2c8d waiting on condition [0xb50f5000]
   java.lang.Thread.State: WAITING (parking)
     at sun.misc.Unsafe.park(Native Method)
     - parking to wait for <0x7a387350> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
     at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2043)
     at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:386)
     at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1043)
     at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1103)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:603)
     at java.lang.Thread.run(Thread.java:636)
   Locked ownable synchronizers:
     - None
"Low Memory Detector" daemon prio=10 tid=0x08938000 nid=0x2c8b runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE
   Locked ownable synchronizers:
     - None
"CompilerThread0" daemon prio=10 tid=0x08936000 nid=0x2c8a waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE
   Locked ownable synchronizers:
     - None
"Signal Dispatcher" daemon prio=10 tid=0x08934800 nid=0x2c89 runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE
   Locked ownable synchronizers:
     - None
"Finalizer" daemon prio=10 tid=0x0892c800 nid=0x2c88 in Object.wait() [0xb5339000]
   java.lang.Thread.State: WAITING (on object monitor)
     at java.lang.Object.wait(Native Method)
     - waiting on <0x7a383068> (a java.lang.ref.ReferenceQueue$Lock)
     at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:133)
     - locked <0x7a383068> (a java.lang.ref.ReferenceQueue$Lock)
     at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:149)
     at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:177)
   Locked ownable synchronizers:
     - None
"Reference Handler" daemon prio=10 tid=0x0892b000 nid=0x2c87 in Object.wait() [0xb538a000]
   java.lang.Thread.State: WAITING (on object monitor)
     at java.lang.Object.wait(Native Method)
     - waiting on <0x7a3830f0> (a java.lang.ref.Reference$Lock)
     at java.lang.Object.wait(Object.java:502)
     at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
     - locked <0x7a3830f0> (a java.lang.ref.Reference$Lock)
   Locked ownable synchronizers:
     - None
"VM Thread" prio=10 tid=0x08929400 nid=0x2c86 runnable
"VM Periodic Task Thread" prio=10 tid=0x08943c00 nid=0x2c8c waiting on condition
JNI global references: 983

Fixed Size Thread Pool which infinitely serve task submitted to it

Hi,
I want to create a fixed size thread pool say of size 100 and i will submit around 200 task to it.
Now i want it to serve them infinitely i.e once all tasks are completed re-do them again and again.
public void start(Vector<String> addresses)
      //Create a Runnable object of each address in "addresses"
       Vector<FindAgentRunnable> runnables = new Vector<FindAgentRunnable>(1,1);
        for (String address : addresses)
            runnables.addElement(new FindAgentRunnable(address));
       //Create a thread pool of size 100
        ExecutorService pool = Executors.newFixedThreadPool(100);
        //Here i added all the runnables to the thread pool
         for(FindAgentRunnable runnable : runnables)
                pool.submit(runnable);
            pool.shutdown();
}Now i wants that this thread pool execute the task infinitely i.e once all the tasks are done then restart all the tasks again.
I have also tried to add then again and again but it throws a java.util.concurrent.RejectedExecutionException
public void start(Vector<String> addresses)
      //Create a Runnable object of each address in "addresses"
       Vector<FindAgentRunnable> runnables = new Vector<FindAgentRunnable>(1,1);
        for (String address : addresses)
            runnables.addElement(new FindAgentRunnable(address));
       //Create a thread pool of size 100
        ExecutorService pool = Executors.newFixedThreadPool(100);
        for(;;)
            for(FindAgentRunnable runnable : runnables)
                pool.submit(runnable);
            pool.shutdown();
            try
                pool.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
            catch (InterruptedException ex)
                Logger.getLogger(AgentFinder.class.getName()).log(Level.SEVERE, null, ex);
}Can anybody help me to solve this problem?
Thnx in advance.

Ravi_Gupta wrote:
*@ kajbj*
so what should i do?
can you suggest me a solution?Consider this thread "closed". Continue to post in your other thread. I, and all others don't want to give answers that already have been given.

How to correctly use a fixed size thread pool?

I am quite new to using concurrency in Java, so please forgive if this is a trivial question.
I would like to make use of something like pool=Executors.newFixedThreadPool(n) to automatically use a fixed number of threads to process pieces of work. I understand that I can asynchronously run some Runnable by one of the threads in the threadpool using pool.execute(someRunnable).
My problem is this: I have some fixed amount of N datastructures myDS (which are not reentrant or sharable) that get initialized at program start and which are needed by the runnables to do the work. So, what I really would like to do is that I not only reuse N threads but also N of these datastructures to do the work.
So, lets say I want to have 10 threads, then I would want to create 10 myDS objects once and for all. Each time some work comes in, I want that work to get processed by the next free thread, using the next free datastructure. What I was wondering is if there is something in the library that lets me do the resusing of threads AND datastructures as simply as just reusing a pool of threads. Ideally, each thread would get associated with one datastructure somehow.
Currently I use an approach where I create 10 Runnable worker objects, each with its own copy of myDS. Those worker objects get stored in an ArrayBlockingQueue of size 10. Each time some work comes in, I get the next Runner from the queue, pass it the piece of work and submit it to the thread pool.
The tricky part is how to get the worker object back into the Queue: currently I essentially do queue.put(this) at the very end of each Runnable's run method but I am not sure if that is safe or how to do it safely.
What are the standard patterns and library classes to use for solving this problem correctly?

Thank you for that feedback!
There is one issue that worries me though and I obviously do not understand it enough: as I said I hand back the Runnable to the blocking queue at the end of the Runnable.run method using queue.put(this). This is done via a static method from the main class that creates the threads and runnable objects in a main method. Originally I tried to make that method for putting back the Runnable objects serialized but that inevitably always led to a deadlock or hang condition: the method for putting back the runnable was never actually run. So I ended up doing this without serializing the put action in any way and so far it seems to work ... but is this safe?
To reiterate: I have a static class that creates a thread pool object and a ArrayBlockingQueue queue object of runnable objects. In a loop I use queue.take() to get the next free runnable object, and pass this runnable to pool.execute. Inside the runnable, in method run, i use staticclass.putBack(this) which in turn does queue.put(therunnableigot). Can I trust that this queue.put operation, which can happen from several threads at the same time works without problem without serializing it explicitly? And why would making the staticclass.putBack method serialized cause a hang? I also tried to serialize using the queue object itself instead of the static class, by doing serialize(queue) { queue.put(therunnable) } but that also caused a hang. I have to admit that I do not understand at all why that hang occurred and if I need the serialization here or not.

Combining the fixed and cached thread pools

Is there a way to 'combine' the behavior of cached and fixed thread pools ? I have a requirement where
- at startup, I need to execute a fixed number of short-lived tasks at the background
- after startup, on demand, I need to run one short-lived task at a time
If I use a fixed thread pool for my startup processing, it creates the fixed number of threads to process the tasks. But subsequently, those many threads are not required since my task submission is going to be one at a time. The remaining (n-1) threads therefore are really sitting idle & useless.
If I use a cached thread pool, then I cannot constrain the number of threads to run at startup (since it creates one for each task). Though it ends up taking those threads out after they are idle for a fixed period. But I'm worried that it might create many threads and possibly slowing down the startup ?
Is there a way to create a pool with a fixed number of threads but 'remove' a set of threads when they are idle ?
TIA

v_bala wrote:
Thanks. The SynchronousQueue worked as expected. But I tried a LinkedBlockingQueue with size 1 hoping that would cause the second task submission to cause a new thread creation. It didn't. Instead it queues up the request (maybe the doc in ThreadPoolExecutor says that when it mentions "If corePoolSize or more threads are running, the Executor always prefers queuing a request rather than adding a new thread"). I suppose if I were to try another it would create another thread ? (I was testing with only two tasks - the first one ended up creating a thread for the task and the next got queued since the queue capacity is 1)yes, the TPE will not start adding threads until the queue starts rejecting them. kind of odd in my opinion, but that's how it works.
Btw, that was an interesting idea to add a task that scale the core pool number down ! Currently it comes back down to just the one thread (my core pool size is one) after the idle timeout but your idea may give me a slightly better response since it will scale down the core pool size quicker....I suppose if there was a task submission before that idle time there maybe a performance hit (but I don't anticipate that in my case )?actually, that won't scale things down any faster. changing the core pool size will not ditch the other threads immediately, they will still stick around until they idle timeout. changing the core pool size allows you to not worry about the queue implementation (the first solution). you can set the initial core pool size to your "max" size on startup, then drop it down for the normal processing, all the while using a linkedblockingqueue of unlimited size.

Will more number of waiting threads in thread pool degrade performance?

Hi,
I use thread pool and set the maximum number of threads to execute. My problem is, the thread pool initiates the number of threads and these threads wait until they get a work. Will this degrade the performance (The threads do I/O operations) ??

Threads waiting for work will not degrade performance. If your work involves those threads waiting for I/O then that in itself will not degrade performance either (as long as they block and don't poll of course).
All live threads consume resources however so if you are short on threads or memory then don't create too many of them.
Pre-starting a large number of threads in a pool can cause a startup delay of course. Generally you should let the pool create threads as needed until it gets to the core pool size.

App Server Freeze - All threads waiting for replication data

          We are running Weblogic 6.1 SP2, on solaris 8 with jdk1.3 When running load at our
          application - full GC is taking between 15 -20 seconds. At a certain point after
          a full GC on one of the servers in the cluster we see session replication errors
          in the logs. The application eventually freezes - the execute queue is huge on each
          of the JVMS and when we do a thread dump we see that all threads are waiting for
          replication data. All threads have the same stack trace as follows:
          "ExecuteThread: '1' for queue: 'default'" daemon prio=5 tid=0x2c58b0 nid=0xe waiting
          on monitor [0xbf980000..0xbf9819d8]
               at java.lang.Object.wait(Native Method)
               at weblogic.rjvm.ResponseImpl.waitForData(ResponseImpl.java:72)
               at weblogic.rjvm.ResponseImpl.getTxContext(ResponseImpl.java:97)
               at weblogic.rmi.internal.BasicOutboundRequest.sendReceive(BasicOutboundRequest.java:80)
               at weblogic.rmi.internal.BasicRemoteRef.invoke(BasicRemoteRef.java:135)
               at weblogic.rmi.internal.ProxyStub.invoke(ProxyStub.java:35)
               at $Proxy74.lookupROIDS(Unknown Source)
               at weblogic.servlet.internal.HttpServer.lookupROIDS(HttpServer.java:761)
               at weblogic.servlet.internal.session.ReplicatedSessionContext.getSessionInternal(ReplicatedSessionContext.java:225)
               at weblogic.servlet.internal.ServletRequestImpl.getValidSession(ServletRequestImpl.java:2130)
               at weblogic.servlet.internal.ServletRequestImpl.getSession(ServletRequestImpl.java:1921)
               at weblogic.servlet.security.internal.ServletSecurityManager.checkAccess(ServletSecurityManager.java:107)
               at weblogic.servlet.internal.WebAppServletContext.invokeServlet(WebAppServletContext.java:2467)
               at weblogic.servlet.internal.ServletRequestImpl.execute(ServletRequestImpl.java:2204)
               at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java:139)
               at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:120)


          Yes this is reproducable. We are now working with BEA Support under Case : 321199.
          Thanks
          Anna
          Kumar Allamraju <[email protected]> wrote:
          >You should work with [email protected]
          >Can this problem be reproduced with an isolated test case?
          >If yes, it will be really helpful for them to work with Engg.
          >
          >--
          >Kumar
          >
          >anna bancroft wrote:
          >
          >> We are running Weblogic 6.1 SP2, on solaris 8 with jdk1.3 When running
          >load at our
          >> application - full GC is taking between 15 -20 seconds. At a certain
          >point after
          >> a full GC on one of the servers in the cluster we see session replication
          >errors
          >> in the logs. The application eventually freezes - the execute queue is
          >huge on each
          >> of the JVMS and when we do a thread dump we see that all threads are waiting
          >for
          >> replication data. All threads have the same stack trace as follows:
          >> "ExecuteThread: '1' for queue: 'default'" daemon prio=5 tid=0x2c58b0 nid=0xe
          >waiting
          >> on monitor [0xbf980000..0xbf9819d8]
          >>      at java.lang.Object.wait(Native Method)
          >>      at weblogic.rjvm.ResponseImpl.waitForData(ResponseImpl.java:72)
          >>      at weblogic.rjvm.ResponseImpl.getTxContext(ResponseImpl.java:97)
          >>      at weblogic.rmi.internal.BasicOutboundRequest.sendReceive(BasicOutboundRequest.java:80)
          >>      at weblogic.rmi.internal.BasicRemoteRef.invoke(BasicRemoteRef.java:135)
          >>      at weblogic.rmi.internal.ProxyStub.invoke(ProxyStub.java:35)
          >>      at $Proxy74.lookupROIDS(Unknown Source)
          >>      at weblogic.servlet.internal.HttpServer.lookupROIDS(HttpServer.java:761)
          >>      at weblogic.servlet.internal.session.ReplicatedSessionContext.getSessionInternal(ReplicatedSessionContext.java:225)
          >>      at weblogic.servlet.internal.ServletRequestImpl.getValidSession(ServletRequestImpl.java:2130)
          >>      at weblogic.servlet.internal.ServletRequestImpl.getSession(ServletRequestImpl.java:1921)
          >>      at weblogic.servlet.security.internal.ServletSecurityManager.checkAccess(ServletSecurityManager.java:107)
          >>      at weblogic.servlet.internal.WebAppServletContext.invokeServlet(WebAppServletContext.java:2467)
          >>      at weblogic.servlet.internal.ServletRequestImpl.execute(ServletRequestImpl.java:2204)
          >>      at weblogic.kernel.ExecuteThread.execute(ExecuteThread.java:139)
          >>      at weblogic.kernel.ExecuteThread.run(ExecuteThread.java:120)
          >>
          >>
          >

Fixed size thread pool excepting more tasks then it should

Hello,
I have the following code in a simple program (code below)
          BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10, false);
          ThreadPoolExecutor newPool = new ThreadPoolExecutor(1, 10, 20, TimeUnit.SECONDS, q);
for (int x = 0; x < 30; x++) {
newPool.execute(new threaded());
My understanding is that this should create a thread pool that will accept 10 tasks, once there have been 10 tasks submitted I should get RejectedExecutionException, however; I am seeing that when I execute the code the pool accepts 20 execute calls before throwing RejectedExecutionException. I am on Windows 7 using Java 1.6.0_21
Any thoughts on what I am doing incorrectly?
Thanks
import java.util.concurrent.*;
public class ThreadPoolTest {
     public static class threaded implements Runnable {
          @Override
          public void run() {
               System.out.println("In thread: " + Thread.currentThread().getId());
               try {
                    Thread.sleep(5000);
               } catch (InterruptedException e) {
                    System.out.println("Thread: " + Thread.currentThread().getId()
                              + " interuptted");
               System.out.println("Exiting thread: " + Thread.currentThread().getId());
     private static int MAX = 10;
     private Executor pool;
     public ThreadPoolTest() {
          super();
          BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(MAX/2, false);
          ThreadPoolExecutor newPool = new ThreadPoolExecutor(1, MAX, 20, TimeUnit.SECONDS, q);
          pool = newPool;
     * @param args
     public static void main(String[] args) {
          ThreadPoolTest object = new ThreadPoolTest();
          object.doThreads();
     private void doThreads() {
          int submitted = 0, rejected = 0;
          for (int x = 0; x < MAX * 3; x++) {
               try {
                    System.out.println(Integer.toString(x) + " submitting");
                    pool.execute(new threaded());
                    submitted++;
               catch (RejectedExecutionException re) {
                    System.err.println("Submission " + x + " was rejected");
                    rejected++;
          System.out.println("\n\nSubmitted: " + MAX*2);
          System.out.println("Accepted: " + submitted);
          System.out.println("Rejected: " + rejected);
}

I don't know what is wrong because I tried this
public static void main(String args[]) {
    BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10, false);
    ThreadPoolExecutor newPool = new ThreadPoolExecutor(1, 10, 20, TimeUnit.SECONDS, q);
    for (int x = 0; x < 100; x++) {
        System.err.println(x + ": " + q.size());
        newPool.submit(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                Thread.sleep(1000);
                return null;
}and it printed
0: 0
1: 0
2: 1
3: 2
4: 3
5: 4
6: 5
7: 6
8: 7
9: 8
10: 9
11: 10
12: 10
13: 10
14: 10
15: 10
16: 10
17: 10
18: 10
19: 10
20: 10
Exception in thread "main" java.util.concurrent.RejectedExecutionException
     at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1768)
     at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:767)
     at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:658)
     at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:92)
     at Main.main(Main.java:36)
     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
     at java.lang.reflect.Method.invoke(Method.java:597)
     at com.intellij.rt.execution.application.AppMain.main(AppMain.java:115)Ihave Java 6 update 24 on Linux, but I don't believe this should make a difference. Can you try my code?

Wait for all threads in a array to die

I everyone. I'm from Portugal and I have some experience in JAVA programming (approximately five years) but this is the first the first time that i'm trying to use threads. I'm trying to learn writing some simpler code that does almost exactly at the basic level the same stuff that a complex application that I need to write for my work.
What I'm trying to do is execute a counter that counts all operations in threads belonging to the same array (an array of n threads).
A static variable in the Thread class (implementing Runnable) counts all operations performed by all threads and sums them all and shoud display the total of operations after all threads terminate, but this exactly what I don't know how to do:
This is my example code:
public class TT1 implements Runnable {
     int id;
     double last_number;
     static int threads_counter = 0;
     static int total_threads = 4;
     static long total_numbers;
     int total_randoms = 1000;
     public void run() {
          for (int i=0;i<total_randoms;i++)
               total_numbers++;
               // does some stuff, in this case, generate a random number!
               last_number = Math.random();
          System.out.printf("Thread %d:%f(%d)\n",id,last_number,total_numbers);
     public TT1() {
          id = threads_counter++;
          new Thread(this).start();
     public static void main(String[] args) {
          // TODO Auto-generated method stub
          Thread [] threads = new Thread[total_threads];
          for (int i=0;i<threads.length;i++)
               threads[i] = new Thread(new TT1());
          /* commented code using join(), is not working or I don't know
          how to use it! */
          for (int i=0;i<threads.length;i++)
               try {
                    threads.join();
               } catch (InterruptedException e) {
                    e.printStackTrace();
          try {
               threads[total_threads-1].join();
          } catch (InterruptedException e) {
               e.printStackTrace();
          // this line should be executed ONLY after ALL threads have died!
          System.out.println("******GENERATED NUMBERS TOTAL:" + total_numbers);
Somebody can give me a hint how to solve this ?

Thanks for your replies.
Actually, i've corrected the code, now i'm starting the threads outside the constructor. Originally I thought this could be a simpler way to create the threads: launching them at same time I'm creating them! Is this wrong ? :) Well, watching the results.
I changed my code:
public class TT1 implements Runnable {
     int id;
     double last_number;
     static int threads_counter = 0;
     static int total_threads = 4;
     static long total_numbers;
     int total_randoms = 1000;
     public void run() {
          for (int i=0;i<total_randoms;i++)
               total_numbers++;
               // does some stuff, in this case, generate a random number!
               last_number = Math.random();
          System.out.printf("Thread %d:%f(%d)\n",id,last_number,total_numbers);
     public TT1() {
          id = threads_counter++;
     public static void main(String[] args) {
          // TODO Auto-generated method stub
          Thread [] threads = new Thread[total_threads];
          /* create individual threads */
          for (int i=0;i<threads.length;i++)
               threads[i] = new Thread(new TT1());
          /* launch the threads (NEW CODE) */
          for (int i=0;i<threads.length;i++)
               threads.start();
          /* commented code using join(), is not working or I don't know
          how to use it! */
          for (int i=0;i<threads.length;i++)
               try {
                    threads[i].join();
               } catch (InterruptedException e) {
                    e.printStackTrace();
          // this line should be executed ONLY after ALL threads have died!
          System.out.println("******GENERATED NUMBERS TOTAL:" + total_numbers);
And I obtain the output:
$ java TT1
Thread 0:0,191546(1000)
Thread 1:0,937476(2000)
Thread 2:0,825079(3000)
Thread 3:0,451367(4000)
******GENERATED NUMBERS TOTAL:4000Exactly as I want it!
All is good when it works good ;)
Best regards

The problem in the thread pool implemented by myself

Hello, I need to a thread pool in J2ME CDC 1.0 + FP 1.0, so I implemented a simple one by myself that also meets my own requirement.
Here is the main idea:
The thread pool creates a fixed number of threads in advance. When a task comes, it is put in the waiting list. All threads tries to get the tasks from the waiting list. If no task exists, the threads wait until someone wakes them up.
Here are the requirements from myself:
1. when a task has finished its work in one execution, it is put in the waiting list for the next run.
2. the task can control the delay between when the task owner tries to put it in the waiting list and when the task is actually put in the waiting list. I need this function because sometimes I don't want the tasks to run too often and want to save some CPU usage.
In my program, I creates two thread pools. In one pool, every task don't use the delay, and the thread pool works very well. The other pool has the tasks that use the delay, and sometimes, as I can see from the printed information, there are many tasks in the waiting list but 0 or 1 thread executes tasks. It seems that the waiting threads cannot wake up when new tasks comes.
I suspect the code in addTask(), but cannot find the reason why it fails. Could anyone please help me find out the bug in my code? I put the code of thread pool below
Thank you in advance
Zheng Da
ThreadPool.java
package j2me.concurrent;
import java.util.LinkedList;
import java.util.Timer;
import java.util.TimerTask;
import alvis.general.Util;
public class ThreadPool {
     private int maxQueueSize;
     private boolean running = true;
     private Thread[] threads;
     private LinkedList tasks = new LinkedList();
     private Timer timer = new Timer(true);
     private AtomicInteger usingThreads = new AtomicInteger(0);
     private synchronized boolean isRunning() {
          return running;
     private synchronized void stopRunning() {
          running = false;
     private synchronized PoolTask getTask() {
          while (tasks.isEmpty() && isRunning()) {
               try {
                    this.wait();
               } catch (InterruptedException e) {
                    e.printStackTrace();
          if (tasks.isEmpty())
               return null;
          // Util.log.info(Thread.currentThread().getName() +
          // " gets a task, left tasks: " + tasks.size());
          return (PoolTask) tasks.removeFirst();
     private synchronized void addTaskNoDelay(PoolTask task) {
          tasks.addLast(task);
          notifyAll();
     private synchronized void addTask(final PoolTask task) {
          long delay = task.delay();
          if (delay == 0) {
               addTaskNoDelay(task);
          } else {
               timer.schedule(new TimerTask() {
                    public void run() {
                         addTaskNoDelay(task);
               }, delay);
     private synchronized int numTasks() {
          return tasks.size();
     private class PoolThread extends Thread {
          public void run() {
               Util.poolThreads.inc();
               while (isRunning()) {
                    PoolTask task = getTask();
                    if (task == null) {
                         Util.poolThreads.dec();
                         return;
                    usingThreads.inc();
                    long currentTime = System.currentTimeMillis();
                    task.run();
                    long elapsedTime = System.currentTimeMillis() - currentTime;
                    if (elapsedTime > 100)
                         System.err.println(task.toString() + " takes " + ((double) elapsedTime)/1000 + "s");
                    usingThreads.dec();
                    if (!task.finish()) {
                         addTask(task);
               Util.poolThreads.dec();
     public ThreadPool(int size, int taskQueueSize) {
          maxQueueSize = taskQueueSize;
          threads = new Thread[size];
          for (int i = 0; i < threads.length; i++) {
               threads[i] = new PoolThread();
               threads.start();
     public synchronized boolean executor(PoolTask task) {
          if (!isRunning()) {
               return false;
          Util.log.info("Thread Pool gets " + task + ", there are "
                    + numTasks() + " waiting tasks");
          if (numTasks() >= maxQueueSize) {
               return false;
          addTask(task);
          return true;
     public synchronized void destroy() {
          stopRunning();
          timer.cancel();
          // TODO: I am not sure it can wake up all threads and destroy them.
          this.notifyAll();
     public synchronized void printSnapshot() {
          System.err.println("using threads: " + usingThreads + ", remaining tasks: " + tasks.size());
PoolTask.javapackage j2me.concurrent;
public interface PoolTask extends Runnable {
     * It shows if the task has already finished.
     * If it isn't, the task will be put in the thread pool for the next execution.
     * @return
     boolean finish();
     * It shows the delay in milliseconds that the task is put in the thread pool.
     * @return
     long delay();

are receiving/sends tasks packets time consuming operation in your case or not? if it is not you do not need to use thread pools at all. you can create a queue like in your code through the linked list and dispatch this queue periodically with minimum monitor usage. try this.
import java.util.LinkedList;
public class PacketDispatcher extends Thread {
    LinkedList list = new LinkedList();
    public PacketDispatcher (String name) {
        super(name);
    public void putTask(Task task) {
        synchronized (list) {
            list
                    .add(task);
            list.notify();
    public void run() {
        while (true/* your condition */) {
            Task task = null;
            synchronized (list) {
                while (list.isEmpty())
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                task = (Task)list
                        .poll();
            if (task == null) {
                try {
                    Thread
                            .sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                continue;
            task
                    .run();
            if (!task.isFinished()) {
                putTask(task);
            Thread
                    .yield();
    public static void main(String[] args) {
        // just for test
        try {
            Thread.sleep (10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        PacketDispatcher dispatcher = new PacketDispatcher("Packet Dispatcher");
        Task task = new Task();
        dispatcher.putTask(task);
        dispatcher.start();
        try {
            Thread.sleep (10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        Task task2 = new Task();
        dispatcher.putTask(task2);
class Task {
    long result = 0;
    public boolean isFinished () {
        if (getResult() >= 10000000) {
            return true;
        return false;
    public void run() {
        for (int i = 0; i < 1000; i++) {
            result += i;
    public long getResult () {
        return result;
}

Multiple thread pools under single executor

I would like to segregate the tasks running in an Executor so that certain tasks (perhaps identified by an annotation) could be restricted to a thread pool of a limited size while others run in a different pool.
The intend is to limit certain crunchy tasks so that they don't saturate a limited resource.
As far as I can tell I can't do this with a ThreadPoolExecutor even with a custom ThreadFactory. The original Callable is wrapped a couple of times by the time the ThreadFactory.newThread method is called so I can't inspect it at that time. Also, once the maximumPoolSize is reached the waiting tasks will get handed off to whichever thread finishes first, thus making my fixed pools useless.
I have a feeling that I will need to write my own ThreadPoolExecutor but I thought that I would ask if there was a way to do this with the existing classes first.
Thanks.

I used to do this.
The problem comes in managing the work that flows between the queues, and managing the results. I need to be able to take the output from one task and feed it into another, potentially running in a different thread pool.
Multiple queues mean waiting for more than one blocking event, which means multiple management threads with a meta-event queue feeding back to an dispatcher that does the messaging.
With multiple management threads you have to poison all of those queues so that the thing shuts down when you are done.
By the time that I'm done I may be better off just modifyingThreadPoolExecutor to do what I want. One work queue keeps the shutdown problem under control.
Thanks for the feedback.

A good design for a single thread pool manager using java.util.concurrent

Hi,
I am developing a client side project which in distinct subparts will execute some tasks in parallel.
So, just to be logorroic, something like that:
program\
            \--flow A\
                       \task A1
                       \task A2
            \--flow B\
                        \task B1
                        \task B2
                        \...I would like both flow A and flow B (and all their launched sub tasks) to be executed by the same thread pool, because I want to set a fixed amount of threads that my program can globally run.
My idea would be something like:
public class ThreadPoolManager {
    private static ExecutorService executor;
    private static final Object classLock = ThreadPoolManager.class;
     * Returns the single instance of the ExecutorService by means of
     * lazy-initialization
     * @return the single instance of ThreadPoolManager
    public static ExecutorService getExecutorService() {
        synchronized (classLock) {
            if (executor != null) {
                return executor;
            } else {
                // TODO: put the dimension of the FixedThreadPool in a property
                executor = Executors.newFixedThreadPool(50);
            return executor;
     * Private constructor: deny creating a new object
    private ThreadPoolManager() {
}The tasks I have to execute will be of type Callable, since I expect some results, so you see an ExecutorService interface above.
The flaws with this design is that I don't prevent the use (for example) of executor.shutdownNow(), which would cause problems.
The alternative solution I have in mind would be something like having ThreadPoolManager to be a Singleton which implements ExecutorService, implementing all the methods with Delegation to an ExecutorService object created when the ThreadPoolManager object is instantiated for the first time and returned to client:
public class ThreadPoolManager implements ExecutorService {
    private static ThreadPoolManager pool;
    private static final Object classLock = ThreadPoolManager.class;
    private ExecutorService executor;
     * Returns the single instance of the ThreadPoolManager by means of
     * lazy-initialization
     * @return the single instance of ThreadPoolManager
    public static ExecutorService getThreadPoolManager() {
        synchronized (classLock) {
            if (pool !=null) {
                return pool;
            } else {
                // create the real thread pool
                // TODO: put the dimension of the FixedThreadPool in a property
                // file
                pool = new ThreadPoolManager();
                pool.executor = Executors.newFixedThreadPool(50);
                // executor = Executors.newCachedThreadPool();
                return pool;
     * Private constructor: deny creating a new object
    private ThreadPoolManager() {
    /* ======================================== */
    /* implement ExecutorService interface methods via delegation to executor
     * (forbidden method calls, like shutdownNow() , will be "ignored")
      // .....I hope to have expressed all the things, and hope to receive an answer that clarifies my doubts or gives me an hint for an alternative solution or an already made solution.
ciao
Alessio

Two things. Firstly, it's better to use     private static final Object classLock = new Object();because that saves you worrying about whether any other code synchronises on it. Secondly, if you do decide to go for the delegation route then java.lang.reflect.Proxy may be a good way forward.

JRun Thread Pool Issue

I'm running CF 9.0.1 on Ubuntu on an "Medium" Amazon EC2 instance. CF has been crashing intermittently (several times per day). At such times, running top gets me this (or something similar):
PID
USER
PR
NI
VIRT
RES
SHR
S
%CPU
%MEM
TIME+COMMAND
15855
wwwrun
20
0
1762m
730m
20m
S
99.3
19.4
13:22.96 coldfusion9
So, it's obviously consuming most of the server resources. The following error has been showing up in my cfserver.log in the leadup to each crash:
java.lang.RuntimeException: Request timed out waiting for an available thread to run. You may want to consider increasing the number of active threads in the thread pool.
If I run /opt/coldfusion9/bin/coldfusion status, I get:
Pg/Sec DB/Sec CP/Sec Reqs Reqs Reqs AvgQ   AvgReq AvgDB Bytes Bytes
Now Hi Now Hi Now Hi Q'ed Run'g TO'ed Time   Time   Time   In/Sec Out/Sec
0   0   0   0   -1 -1 150   25    0     0      -1352560      0      0
In the administrator, under Server Settings > Request Tuning, the setting for Maximum number of simultaneous Template requests is 25. So this makes sense so far. I could just increase the thread pool to cover these sort of load spikes. I could make it 200. (Which I did just now as a test.)
However, there's also this file /opt/coldfusion9/runtime/servers/coldfusion/SERVER-INF/jrun.xml. And some of the settings in there appear to conflict. For example, it reads:
<service class="jrunx.scheduler.SchedulerService" name="SchedulerService">
<attribute name="bindToJNDI">true</attribute>
<attribute name="activeHandlerThreads">25</attribute>
<attribute name="maxHandlerThreads">1000</attribute>
<attribute name="minHandlerThreads">20</attribute>
<attribute name="threadWaitTimeout">180</attribute>
<attribute name="timeout">600</attribute>
</service>
Which a) has fewer active threads (what does this mean?), and b) has a max threads that exceed the simultaneous request limit set in the admin. So, I'm not sure. Are these independent configs that need to be made to match manually? Or is the jrun.xml file supposed to be written by the CF Admin when changes are made there? Hmm. But maybe this is different because presumably the CF Scheduler should only use a subset of all available threads, right...so we'd always have some threads for real live users. We also have this in there:
<service class="jrun.servlet.http.WebService" name="WebService">
<attribute name="port">8500</attribute>
<attribute name="interface">*</attribute>
<attribute name="deactivated">true</attribute>
<attribute name="activeHandlerThreads">200</attribute>
<attribute name="minHandlerThreads">1</attribute>
<attribute name="maxHandlerThreads">1000</attribute>
<attribute name="mapCheck">0</attribute>
<attribute name="threadWaitTimeout">300</attribute>
<attribute name="backlog">500</attribute>
<attribute name="timeout">300</attribute>
</service>
This appears to have changed when I changed the CF Admin setting...maybe...but it's the activeHandlerThreads that matches my new maximum simulataneous requests setting...rather than the maxHandlerThreads, which again exceeds it. Finally, we have this:
<service class="jrun.servlet.jrpp.JRunProxyService" name="ProxyService">
<attribute name="activeHandlerThreads">200</attribute>
<attribute name="minHandlerThreads">1</attribute>
<attribute name="maxHandlerThreads">1000</attribute>
<attribute name="mapCheck">0</attribute>
<attribute name="threadWaitTimeout">300</attribute>
<attribute name="backlog">500</attribute>
<attribute name="deactivated">false</attribute>
<attribute name="interface">*</attribute>
<attribute name="port">51800</attribute>
<attribute name="timeout">300</attribute>
<attribute name="cacheRealPath">true</attribute>
</service>
So, I'm not certain which (if any) of these I should change and what exactly the relationship is between maximum requests and maximum threads. Also, since several of these list the maxHandlerThreads as 1000, I'm wondering if I should just set the maximum simultaneous requests to 1000. There must be some upper limit that depends on available server resources...but I'm not sure what it is and I don't really want to play around with it since it's a production environment.
I'm not sure if it pertains to this issue at all, but when I run a ps aux | grep coldfusion I get the following:
wwwrun   15853 0.0 0.0   8704   760 pts/1
S
20:22   0:00 /opt/coldfusion9/runtime/bin/coldfusion9 -jar jrun.jar -autorestart -start coldfusion
wwwrun   15855 5.4 18.2 1678552 701932 pts/1
Sl
20:22   1:38 /opt/coldfusion9/runtime/bin/coldfusion9 -jar jrun.jar -start coldfusion
There are always these two and never more than these two processes. So there does not appear to be a one-to-one relationship between processes and threads. I recall from an MX 6.1 install I maintained for many years that additional CF processes were visible in the process list. It seemed to me at the time like I had a process for each thread...so either I was wrong or something is quite different in version 9 since it's reporting 25 running requests and only showing these two processes. If a single process can have multiple threads in the background, then I'm given to wonder why I have two processes instead of one...just curious.
So, anyway, I've been experimenting while composing this post. As noted above I adjusted the maximum simulataneous requests up to 200. I was hoping this would solve my problem, but CF just crashed again (rather it slogged down and requests started timing out...so effectively "crashed"). This time, top looked similar (still consuming more than 99% of the CPU), but CF status looked different:
Pg/Sec DB/Sec CP/Sec Reqs Reqs Reqs AvgQ   AvgReq AvgDB Bytes Bytes
Now Hi Now Hi Now Hi Q'ed Run'g TO'ed Time   Time   Time   In/Sec Out/Sec
0   0   0   0   -1 -1 0     150   0     0      0      0      0      0
Obviously, since I'd increased the maximum simultaneous requests, it was allowing more requests to run simultaneously...but it was still maxing out the server resources.
Further experiments (after restarting CF) showed me that the server became unusably slogged after about 30-35 "Reqs Run'g", with all additional requests headed for an inevitible timeout:
Pg/Sec DB/Sec CP/Sec Reqs Reqs Reqs AvgQ   AvgReq AvgDB Bytes Bytes
Now Hi Now Hi Now Hi Q'ed Run'g TO'ed Time   Time   Time   In/Sec Out/Sec
0   0   0   0   -1 -1 0     33    0     0      -492   0      0      0
So, it's clear that increasing the maximum simultaneous requests has not helped. I guess what it comes down to is this: What is it having such a hard time with? Where are these spikes coming from? Bursts of traffic? On what pages? What requests are running at any given time? I guess I simply need more information to continue troubleshooting. If there are long-running requests, or other issues, I'm not seeing it in the logs (although I do have that option checked in the admin). I need to know which requests exactly are those responsible for these spikes. Any help would be much appreciated. Thanks.
~Day

I really appreciate your help. However, I haven't been able to find the JRun Thread settings you describe above.
Under Request Tuning, I see:
Server Settings > Request Tuning
Request Limits
Maximum number of simultaneous Template requests
Restricts the number of simultaneously processed requests. Use this setting to increase overall system performance for heavy load applications. Requests beyond the specified limit are queued. On Standard Edition, you must restart ColdFusion to enable this setting.
Maximum number of simultaneous Flash Remoting requests
The number of Flash Remoting requests that can be processed concurrently.
Maximum number of simultaneous Web Service requests
The number of Web Service requests that can be processed concurrently.
Maximum number of simultaneous CFC function requests
The number of ColdFusion Component methods that can be processed concurrently via HTTP. This does not affect invocation of CFC methods from within CFML, only methods requested via an HTTP request.
Tag Limit Settings
Maximum number of simultaneous Report threads
The maximum number of ColdFusion reports that can be processed concurrently.
Maximum number of threads available for CFTHREAD
The maximum number of threads created by CFTHREAD that will be run concurrently. Threads created by CFTHREAD in excess of this are queued. On Standard Edition, the maximum limit is 10.
And under Java and JVM, I see:
Server Settings > Java and JVM
    Java and JVM settings control the way ColdFusion starts the Java Virtual Machine when it starts. You can control settings like what classpaths are used and how memory is allocated as well as add custom command line arguments. Changing these settings requires restarting ColdFusion. If you enter an incorrect setting, ColdFusion may not restart properly.
   Backups of the jvm.config file are created when you hit the submit button. You can use this backup to restore from a critical change.
   Java Virtual Machine Path
Specifies the location of the Java Virtual Machine.
   Minimum JVM Heap Size (MB)         Maximum JVM Heap Size (MB)
   The Memory Size settings determine the amount of memory that the JVM can use for programs and data.
   ColdFusion Class Path
Specifies any additional class paths for the JVM, with multiple directories separated by commas.
   JVM Arguments
-server -Dsun.io.useCanonCaches=false -XX:MaxPermSize=192m -XX:+UseParallelGC -Xbatch -Dcoldfusion.rootDir={application.home}/../ -Dcoldfusion.libPath={application.home}/../lib
Specifies any specific JVM initialization options, separated by spaces.
I did go take a look at FusionReactor and found it's not free (which would be fine, of course, if it would actually help). It looks like there's a fully functional demo, which is cool...but I've haven't been able to get it to install yet, so we'll see.
Thanks again!
~Day
(By the way, I've cross-posted this inquiry on StackOverflow. So if you're able to help me arrive at a solution you might want to answer there as well.)

Custom thread pool for Java 8 parallel stream

It seems that it is not possible to specify thread pool for Java 8 parallel stream. If that's so, the whole functionality is useless in most of the situations. The only situation I can safely use it is a small single threaded application written by one person.
In all other cases, if I can not specify the thread pool, I have to share the default pool with other parts of the application. If someone submits a task that takes a lot of time, my tasks will get stuck. Is that correct or am I overlooking something?
Imagine that someone submits slow networking operation to the fork-join pool. It's not a good idea, but it's so tempting that it will be happening. In such case, all CPU intensive tasks executed on parallel streams will wait for the networking task to finish. There is nothing you can do to defend your part of the application against such situations. Is that so?

You are absolutely correct. That isn't the only problem with using the F/J framework as the parallel engine for bulk operations. Have a look http://coopsoft.com/ar/Calamity2Article.html

Thread pool rejecting threads when I don't think it should, ideas?

Hi,
I have a server application in which I only want a specific number of simultaneous requests. If the server gets more then this number it is suppose to close the connection (sends an HTTP 503 error to the client). To do this I used a fix thread pool. When I start the server and submit the max number of requests I get the expected behavior. However if I resubmit the request (within a small period of time, e.g. 1-15 seconds after the first one) I get very odd behavior in that some of the requests are rejected. For example if I set the max to 100 the first set of requests will work fine (100 requests, 100 responses). I then submit again and a small number will be rejected (I've seen it range from 1 to 15 rejected)....
I made a small app which kind of duplicates this behavior (see below). Basically when I see is that the first time submitting requests works fine but the second time I get a rejected one. As best as I can tell none should be rejected....
Here is the code, I welcome your thoughts or if you see something I am doing wrong here...
<pre>
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadPoolTest {
     static AtomicInteger count = new AtomicInteger();
     public static class threaded implements Runnable {
          @Override
          public void run() {
               System.out.println("In thread: " + Thread.currentThread().getId());
               try {
                    Thread.sleep(500);
               } catch (InterruptedException e) {
                    System.out.println("Thread: " + Thread.currentThread().getId()
                              + " interuptted");
               System.out.println("Exiting run: " + Thread.currentThread().getId());
     private static int maxThreads = 3;
     private ThreadPoolExecutor pool;
     public ThreadPoolTest() {
          super();
          pool = new java.util.concurrent.ThreadPoolExecutor(
                    1, maxThreads - 1, 60L, TimeUnit.SECONDS,
                    new ArrayBlockingQueue<Runnable>(1));
     public static void main(String[] args) throws InterruptedException {
          ThreadPoolTest object = new ThreadPoolTest();
          object.doThreads();
          Thread.sleep(3000);
          object.doThreads();
          object.pool.shutdown();
          try {
               object.pool.awaitTermination(60, TimeUnit.SECONDS);
          } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
     private void doThreads() {
          int submitted = 0, rejected = 0;
          int counter = count.getAndIncrement();
          for (int x = 0; x < maxThreads ; x++) {
               try {
                    System.out.println("Run #: " + counter + " submitting " + x);
                    pool.execute(new threaded());
                    submitted++;
               catch (RejectedExecutionException re) {
                    System.err.println("\tRun #: " + counter + ", submission " + x
                              + " was rejected");
                    System.err.println("\tQueue active: " + pool.getActiveCount());
                    System.err.println("\tQueue size: " + pool.getPoolSize());
                    rejected++;
          System.out.println("\n\n\tRun #: " + counter);
          System.out.println("\tSubmitted: " + (submitted + rejected));
          System.out.println("\tAccepted: " + submitted);
          System.out.println("\tRejected: " + rejected + "\n\n");
</pre>

First thank you for taking the time to reply, I do appreciate it.
jtahlborn - The code provided here is a contrived example trying to emulate the bigger app as best as I could. The actual program doesn't have any sleeps, the sleep in the secondary thread is to simulate the program doing some work & replying to a request. The sleep in the primary thread is to simulate a small delay between 'requests' to the pool. I can make this 1 second and up to (at least) 5 seconds with the same results. Additionally I can take out the sleep in the secondary thread and still see the a rejection.
EJP - Yes I am aware of the TCP/IP queue, however; I don't see that as relevant to my question. The idea is not to prevent the connection but to respond to the client saying we can't process the request (send an "HTTP 503" error). So basically if we have, say, 100 threads running then the 101st, connection will get a 503 error and the connection will be closed.
Also my test platform - Windows 7 64bit running Java 1.6.0_24-b07 (32bit) on an Intel core i7.
It occurred to me that I did not show the output of the test program. As the output shows below, the first set of requests are all processed properly. The second set of requests is not. The pool should have 2 threads and 1 slot in the queue, so by the time the second "request" is made at least 2 of the requests from the first call should be done processing, so I could possibly understand run 1, submit #2 failing but not submit 1.
<pre>
Run #: 0 submitting 0
Run #: 0 submitting 1
Run #: 0 submitting 2
In thread: 8
In thread: 9
Exiting run: 8
Exiting run: 9
     Run #: 0
     Submitted: 3
     Accepted: 3
     Rejected: 0
In thread: 8
Exiting run: 8
Run #: 1 submitting 0
In thread: 9
Run #: 1 submitting 1
     Run #: 1, submission 1 was rejected
     Queue active: 1
     Queue size: 2
Run #: 1 submitting 2
     Run #: 1
     Submitted: 3
     Accepted: 2
     Rejected: 1
In thread: 8
Exiting run: 9
Exiting run: 8
</pre>

Waiting all threads in a fixed thread pool

Similar Messages

Maybe you are looking for