A simple thread pool implementation

最新推荐文章于 2023-05-23 22:18:15 发布

willpowerforever

最新推荐文章于 2023-05-23 22:18:15 发布

阅读量136

点赞数

分类专栏： Study 学习文章标签： thread IE

Study 学习专栏收录该内容

36 篇文章

订阅专栏

java 代码

import java.util.Vector;
/**
* Thread pool
*/
public class ThreadPool implements Runnable {
// Default ThreadPool minimum size
public final static int DEFAULT_MIN_SIZE = 0;
// Default ThreadPool maximum size
public final static int DEFAULT_MAX_SIZE = Integer.MAX_VALUE;
public final static long DEFAULT_RELEASE_DELAY = 10 * 1000;
// customized thread pool minimum size
protected int minSize;
// customized thread pool maximum size
protected int maxSize;
protected long releaseDelay;
// current threads size in threadpool
protected int currentSize;
protected int availableThreads;
// task list
protected Vector taskList;
/**
* customized ThradPool
*
* @param minSize
* minimum thread pool size
* @param maxSize
* maximum thread pool size
* @param releaseDelay
* threads release delay
*/
public ThreadPool(int minSize, int maxSize, long releaseDelay) {
this.minSize = minSize;
this.maxSize = maxSize;
this.releaseDelay = releaseDelay;
taskList = new Vector(100);
availableThreads = 0;
}
/**
* Default ThreadPool
*/
public ThreadPool() {
this(DEFAULT_MIN_SIZE, DEFAULT_MIN_SIZE, DEFAULT_RELEASE_DELAY);
}
/**
* set minimum thread pool size
*
* @param minSize
* minimum thread pool size
*/
public synchronized void setMinSize(int minSize) {
this.minSize = minSize;
}
/**
* get minimum thread pool size
*/
public synchronized int getMinSize() {
return minSize;
}
/**
* set maximum thread pool size
*
* @param maxSize
* maximum thread pool size
*/
public synchronized void setMaxSize(int maxSize) {
this.maxSize = maxSize;
}
/**
* get maximum thread pool size
*/
public synchronized int getMaxSize() {
return maxSize;
}
/**
* set thread release delay
*
* @param releaseDelay
* thread release delay time
*/
public synchronized void setReleaseDelay(long releaseDelay) {
this.releaseDelay = releaseDelay;
}
/**
* get thread release delay
*/
public synchronized long getReleaseDelay() {
return releaseDelay;
}
/**
* add a task to task list of ThreadPool
*
* @param runnable
* new task
*/
public synchronized void addTask(Runnable runnable) {
taskList.addElement(runnable);
if (availableThreads > 0) {
this.notify();
} else {
if (currentSize < maxSize) {
Thread t = new Thread(this);
currentSize++;
t.start();
}
}
}
public void run() {
Runnable task;
while (true) {
synchronized (this) {
if (currentSize > maxSize) {
currentSize--;
break;
}
task = getNextTask();
if (task == null) {
try {
availableThreads++;
wait(releaseDelay);
availableThreads--;
} catch (InterruptedException ie) {
// do something you wanna
}
task = getNextTask();
if (task == null) {
if (currentSize < minSize)
continue;
currentSize--;
break;
}
}
}
try {
task.run();
} catch (Exception e) {
System.err.println("Uncaught exception");
e.printStackTrace(System.err);
}
}
}
/**
* get the next task from task list.
*
*/
protected synchronized Runnable getNextTask() {
Runnable task = null;
if (taskList.size() > 0) {
task = (Runnable) (taskList.elementAt(0));
taskList.removeElementAt(0);
}
return task;
}
/**
* return thread pool message
*/
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("DEFAULT_MIN_SIZE : " + DEFAULT_MIN_SIZE + "\n");
sb.append("DEFAULT_MAX_SIZE : " + DEFAULT_MAX_SIZE + "\n");
sb.append("DEFAULT_RELEASE_DELAY : " + DEFAULT_RELEASE_DELAY + "\n");
sb.append("the information about your's construct ThreadPool below : \n");
sb.append("minSize \t maxSize \t releaseDelay \n");
sb.append(minSize + "\t" + maxSize + "\t" + releaseDelay);
return sb.toString();
}
}