Java ThreadPool Example

Question

Some people asked at this forum: "How to write Java Threadpool?" Here is an example, which I have tested on the computer with two CPU. This example also runs well with J#.
TPTest.java
package demo.test;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Calendar;
import thread.util.ThreadPool;
class ShutdownHook extends Thread {
    public void run() {
        try {
            MyRunnable.fout.flush();
            Thread.sleep(1000);
            MyRunnable.fout.close();
        catch (Exception e) {
            e.printStackTrace();
class MyRunnable implements Runnable {
    public static File file;
    public static FileWriter fout;
     public static PrintStream out;
    static {
        try {
            file = new File(".\\ThreadPool.log");
            fout = new FileWriter(file);
               out = System.out;
            //Uncomment the next line in J#
            //Runtime.getRuntime().runFinalizersOnExit(true);
            //Comment the next line in J#
            Runtime.getRuntime().addShutdownHook(new ShutdownHook());
        catch (IOException e) {
            e.printStackTrace();
    static int n = 0;
    int i;
    public MyRunnable(int i) {
        this.i = i;
    public void run() {
        try {
            synchronized(fout) {
                n++;
                fout.write("Sample No." + n + "\t" + Calendar.getInstance().getTime().getMinutes() + ":" +
                Calendar.getInstance().getTime().getSeconds() + ":" +
                Calendar.getInstance().get(Calendar.MILLISECOND) +  
                ":" + "Executed: " + this + Thread.currentThread() + "\r\n");
                    out.println("Sample No." + n + "\t" + Calendar.getInstance().getTime().getMinutes() + ":" +
                Calendar.getInstance().getTime().getSeconds() + ":" +
                Calendar.getInstance().get(Calendar.MILLISECOND) +  
                ":" + "Executed: " + this + Thread.currentThread());
        catch (IOException e) {
            e.printStackTrace();
        synchronized(this) {
            notify();
    public String toString() {
        return "Task No." + i;
public class TPTest {
    public static void main(String[] args) {
        ThreadPool thp = new ThreadPool(100);
        int count = 10000;
        for (int i = 0; i < count; i++) {
            if(i == count - 1)
                // Wait for the last Invoke
                ThreadPool.invokeAndWait(thp, new MyRunnable(i));
            else
                ThreadPool.invokeLater(thp, new MyRunnable(i));
        try {
            MyRunnable.fout.flush();
            MyRunnable.fout.close();
        }catch(Exception e) {
        System.exit(0);
Queue.java
package thread.util;
import java.util.Enumeration;
class NoSuchElementException extends RuntimeException {
    public NoSuchElementException() {
        super();
    public NoSuchElementException(String s) {
        super(s);
class QueueElement {
    QueueElement next = null;
    QueueElement prev = null;
    Object obj = null;
    QueueElement(Object obj) {
        this.obj = obj;
    public String toString() {
        return "QueueElement[obj="
            + obj
            + (prev == null ? " null" : " prev")
            + (next == null ? " null" : " next")
            + "]";
final class LIFOQueueEnumerator implements Enumeration {
    Queue queue;
    QueueElement cursor;
    LIFOQueueEnumerator(Queue q) {
        queue = q;
        cursor = q.head;
    public boolean hasMoreElements() {
        return (cursor != null);
    public Object nextElement() {
        synchronized (queue) {
            if (cursor != null) {
                QueueElement result = cursor;
                cursor = cursor.next;
                return result.obj;
        throw new NoSuchElementException("NoSuchElement");
final class FIFOQueueEnumerator implements Enumeration {
    Queue queue;
    QueueElement cursor;
    FIFOQueueEnumerator(Queue q) {
        queue = q;
        cursor = q.tail;
    public boolean hasMoreElements() {
        return (cursor != null);
    public Object nextElement() {
        synchronized (queue) {
            if (cursor != null) {
                QueueElement result = cursor;
                cursor = cursor.prev;
                return result.obj;
        throw new NoSuchElementException("FIFOQueueEnumerator");
public class Queue {
    int length = 0;
    QueueElement head = null;
    QueueElement tail = null;
    public Queue() {
    public synchronized void enqueue(Object obj) {
        QueueElement newElt = new QueueElement(obj);
        if (head == null) {
            head = newElt;
            tail = newElt;
            length = 1;
        else {
            newElt.next = head;
            head.prev = newElt;
            head = newElt;
            length++;
    public synchronized Object dequeue() {
        QueueElement elt = tail;
        tail = elt.prev;
        if (tail == null) {
            head = null;
        else {
            tail.next = null;
        length--;
        return elt.obj;
    public synchronized boolean isEmpty() {
        return (tail == null);
    public final synchronized Enumeration elements() {
        return new LIFOQueueEnumerator(this);
    public final synchronized Enumeration reverseElements() {
        return new FIFOQueueEnumerator(this);
    public synchronized void dump(String msg) {
        System.err.println(">> " + msg);
        System.err.println(
                + length
                + " elt(s); head = "
                + (head == null ? "null" : (head.obj) + "")
                + " tail = "
                + (tail == null ? "null" : (tail.obj) + ""));
        QueueElement cursor = head;
        QueueElement last = null;
        while (cursor != null) {
            System.err.println("  " + cursor);
            last = cursor;
            cursor = cursor.next;
        if (last != tail) {
            System.err.println("  tail != last: " + tail + ", " + last);
        System.err.println("]");
QueueException.java
package thread.util;
public class QueueException extends RuntimeException {
ThreadPool.java
package thread.util;
* A thread pool with a bounded task queue and fixed number of worker threads.
public class ThreadPool {
    public static ThreadPool currentThreadPool = null;
    public Queue queue;
    public ThreadPool(int threads) {
        queue = new Queue();
        /* create the worker threads */
        for (int i = 0; i < threads; ++i) {
            Thread t = new Thread(new WorkerThread(), "WorkerThread: " + (i + 1));
            t.setDaemon(true);
            t.start();
     * Queues a task to be executed by this ThreadPool. If the task queue is
     * full, the task will run in the calling thread. (Could easily be modified
     * to throw an exception instead.)
    public void doTask(Runnable task) {
        synchronized (queue) {
            queue.enqueue(task);
            queue.notify();
     * Tests if the task queue is empty.  Useful if you want to wait for all
     * queued tasks to complete before terminating your program.
    public boolean queueEmpty() {
        synchronized (queue) {
            return queue.isEmpty();
    private class WorkerThread implements Runnable {
        public void run() {
            Runnable task;
            while (true) {
                task = null;
                synchronized (queue) {
                    try {
                        if (queue.isEmpty()) {
                            queue.wait();
                        else {
                            task = (Runnable)queue.dequeue();
                    catch (InterruptedException e) {
                        break;
                if (task != null) {
                    task.run();
    } /* end inner class WorkerThread */
    public static void invokeLater(ThreadPool thp, Runnable task) {
        thp.doTask(task);
    public static void invokeAndWait(ThreadPool thp, Runnable task) {
        TaskWrapper tw = new TaskWrapper(task);
        synchronized(tw.task) {
            try {
                thp.doTask(tw);
                tw.task.wait();
            catch (InterruptedException e) {
            tw = null;
    public static void invokeLater(Runnable task) {
        if(ThreadPool.currentThreadPool == null) {
            ThreadPool.currentThreadPool = new ThreadPool(20);
        ThreadPool.currentThreadPool.doTask(task);
    public static void invokeAndWait(Runnable task) {
        if(ThreadPool.currentThreadPool == null) {
            ThreadPool.currentThreadPool = new ThreadPool(20);
        TaskWrapper tw = new TaskWrapper(task);
        synchronized(tw.task) {
            try {
                ThreadPool.currentThreadPool.doTask(tw);
                tw.task.wait();
            catch (InterruptedException e) {
            tw = null;
} /* end class ThreadPool */
class TaskWrapper implements Runnable {
    public Runnable task;
    public TaskWrapper(Runnable task) {
        this.task = task;
    public void run() {
        synchronized(task) {
            task.run();
            task.notify();

Answer 1

Thanks for the example. I was wondering how to do this.
I am running it right now on Fedora Linux.
When I run the demo TPTest.java
as written
ThreadPool thp = new ThreadPool(100);
int count = 10000;
I get and error at the very end of the run like this :
Sample No.10000     32:36:289:Executed: Task No.652Thread[WorkerThread: 10,5,main]
java.io.IOException: Stream closed
     at sun.nio.cs.StreamEncoder.ensureOpen(StreamEncoder.java:38)
     at sun.nio.cs.StreamEncoder.flush(StreamEncoder.java:151)
     at java.io.OutputStreamWriter.flush(OutputStreamWriter.java:213)
     at demo.test.ShutdownHook.run(TPTest.java:14)
Is this correct behaviour?
General this the only error I see. If I start changing the count and Threadpool size to
other combinations, I occasionally get other errors similar to this one as well.
java.io.IOException: Stream closed
     at sun.nio.cs.StreamEncoder.ensureOpen(StreamEncoder.java:38)
     at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:129)
     at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:146)
     at java.io.OutputStreamWriter.write(OutputStreamWriter.java:204)
     at java.io.Writer.write(Writer.java:126)
     at demo.test.MyRunnable.run(TPTest.java:53)
     at thread.util.ThreadPool$WorkerThread.run(ThreadPool.java:58)
     at java.lang.Thread.run(Thread.java:534)
Is there a way to increase thread size with java on Fedora Linux (Core 3)?
Would like to know. This example was interesting to me because I am trying to push
the limit for load testing purposes.
Thanks again for the example. Let me know if you have any updates to this one.