Very basic implementation of a thread pool : Thread Pool « Threads « Java






Very basic implementation of a thread pool

Very basic implementation of a thread pool
   
/*
 * Copyright (c) 2004, Rob Gordon.
 */
// revised from oddjob

import java.util.LinkedList;


/**
 * Very basic implementation of a thread pool.
 * 
 * @author Rob Gordon.
 */
public class ThreadPool {

    private BlockingQueue queue = new BlockingQueue();
    private boolean closed = true;

    private int poolSize = 3;
    
    
    public void setPoolSize(int poolSize) {
        this.poolSize = poolSize;
    }
    
    public int getPoolSize() {
        return poolSize;
    }
    
    synchronized public void start() {
        if (!closed) {
            throw new IllegalStateException("Pool already started.");
        }
        closed = false;
        for (int i = 0; i < poolSize; ++i) {
            new PooledThread().start();
        }
    }

    synchronized public void execute(Runnable job) {
        if (closed) {
            throw new PoolClosedException();
        }
        queue.enqueue(job);
    }
    
    private class PooledThread extends Thread {
        
        public void run() {
            while (true) {
                Runnable job = (Runnable) queue.dequeue();
                if (job == null) {
                    break;
                }
                try {
                    job.run();
                } catch (Throwable t) {
                    // ignore
                }
            }
        }
    }

    public void close() {
        closed = true;
        queue.close();
    }
    
    private static class PoolClosedException extends RuntimeException {
        PoolClosedException() { 
            super ("Pool closed.");
        }
    }
}
/*
 * Copyright  2004, Rob Gordon.
 */

/**
 *
 * @author Rob Gordon.
 */
 class BlockingQueue {

  private final LinkedList list = new LinkedList();
  private boolean closed = false;
  private boolean wait = false;
  
  synchronized public void enqueue(Object o) {
    if (closed) {
      throw new ClosedException();
    }
    list.add(o);
    notify();
  }

  synchronized public Object dequeue() {
    while (!closed && list.size() == 0) {
      try {
        wait();
      }
      catch (InterruptedException e) {
        // ignore
      }
    }
    if (list.size() == 0) {
      return null;
    }
    return list.removeFirst();
  }
  
  synchronized public int size() {
      return list.size();
  }
  
  synchronized public void close() {
    closed = true;
    notifyAll();
  }
  
  synchronized public void open() {
      closed = false;
  }
  
  public static class ClosedException extends RuntimeException {
      ClosedException() {
          super("Queue closed.");
      }
  }
}

   
    
    
  








Related examples in the same category

1.Defining a thread for a thread poolDefining a thread for a thread pool
2.Thread pool demo
3.Thread Pools 1
4.Thread Pools 2Thread Pools 2
5.Thread pool
6.Thread Pool 2Thread Pool 2
7.Thread Pool TestThread Pool Test
8.JDK1.5 provides a mechanism to create a pool a scheduled task
9.Thread Cache
10.Simple pool of ThreadsSimple pool of Threads
11.Worker thread pool
12.Create a new thread for the thread pool. The create thread will be a daemon thread.
13.Simple thread pool. A task is executed by obtaining a thread from the poolSimple thread pool. A task is executed by obtaining a thread from the pool
14.Simple object pool. Based on ThreadPool and few other classes
15.A utility class that receives a collection of tasks to execute internally and then distributes the tasks among a thread pool.