线程池测试

/**
 * 一个线程池包含4个部分
 * 1:线程池管理器:用于创建并管理线程池，包括 创建线程池  销毁线程池  添加任务
 * 2：工作线程:线程池中的线程，在没有任务时处于等待状态，可以循环的执行任务
 * 3:任务接口:每个任务实现的接口，以供工作线程调度任务执行，它主要规定了任务的入口，任务执行后的收尾工作，任务的执行状态等
 * 4:任务队列:用于存放没有处理的任务，提供一种缓冲机制
 * @author Administrator
 *
 */


import java.util.LinkedList;
import java.util.List;


import jdk.internal.dynalink.beans.StaticClass;


public class ThreadPool {


//线程池中默认的线程个数
private static int worker_num=5;
//工作线程
private WorkThread[] workThreads;
//未处理的任务
private static volatile int finished_task=0;
//任务队列，作为一个缓冲
private List<Runnable> taskQueue=new LinkedList<>();
//线程池
private static ThreadPool threadPool;
//创建具有默认线程个数的线程池
private ThreadPool() {
// this(5);
}
//创建线程池，worker_num为线程池中的工作线程个数
private ThreadPool(int worker_num){
threadPool.worker_num=worker_num;
workThreads=new WorkThread[worker_num];
for (int i = 0; i < worker_num; i++) {
workThreads[i]=new WorkThread();
//开启线程池中的线程
workThreads[i].start();
}

}
//执行任务，其实只是把任务加入到队列中，什么时候执行由线程池管理器决定
public void excute(Runnable[] task){
synchronized (taskQueue) {
for (Runnable runnable : task) {
taskQueue.add(runnable);
taskQueue.notify();
}
}

}
//批量执行任务
public void excute(List<Runnable> task){
synchronized (taskQueue) {
for (Runnable runnable : task) {
taskQueue.add(runnable);
taskQueue.notify();
}
}

}
//销毁线程池，该方法保证所有任务都完成的情况下才销毁线程，否则等待任务完成才销毁
public void destory(){
//如果还有任务没有完成，睡眠2秒
while (!taskQueue.isEmpty()) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//工作线程停止，且置为null
for (int i = 0; i <worker_num; i++) {
workThreads[i].stopWork();
workThreads[i]=null;
}
threadPool=null;
//清空队列
taskQueue.clear();
}
//返回工作线程数
public int getWorkThreadNum(){
return worker_num;
}
//返回已经完成的任务个数，这里指的完成是任务队列中的任务
public int getFinishedTaskNum(){
return finished_task;
}
//返回任务队列的长度，即还没有处理的任务对了
public int getWaitTaskNum(){
return taskQueue.size();
}
//单态模式，获得一个指定线程个数的线程池，
public static ThreadPool getThreadPool(int work_num1) {

if (work_num1<=0) {
work_num1=threadPool.worker_num;
}
if (threadPool==null) {
threadPool=new ThreadPool(work_num1);
}
return threadPool;
}
//单态模式 获得一个默认线程个数的线程池
public static ThreadPool geThreadPool(){
return getThreadPool(threadPool.worker_num);
}
//内部类 工作线程
private class WorkThread extends Thread{
//判断该工作线程是否有效，用于结束工作线程
private boolean isRunning=true;
//如果任务队列不为空，则取出任务执行,若任务队列为空，则等待
@Override
public void run() {


Runnable runnable=null;
//若线程无效，则自动结束run方法
while (isRunning) {
synchronized (taskQueue) {
while (isRunning&&taskQueue.isEmpty()) {
try {
taskQueue.wait(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (!taskQueue.isEmpty()) {
runnable=taskQueue.remove(0);
}
if (runnable!=null) {
//执行任务
runnable.run();
}
finished_task++;
runnable=null;
}
}
}
//停止工作
public void stopWork(){
isRunning=false;
}
}
//任务类
static class Task implements Runnable{
private static volatile int i=1;
@Override
public void run() {
System.out.println("任务+"+i+++"完成任务");
}



}
public static void main(String[] args) {
//创建3个的线程池
ThreadPool t=ThreadPool.getThreadPool(10);
t.excute(new Runnable[]{new Task(),new Task(),new Task(),new Task()});
t.excute(new Runnable[]{new Task(),new Task(),new Task(),new Task()});
System.out.println(t);
t.destory();
System.err.println(t);
}

}

测试结果