The problem in the thread pool implemented by myself

Question

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();

Answer 1

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;       
}