线程池示例代码

admin126com

包结构
src
  test
    TestThreadPool          测试类
  thread
    ThreadPool              线程池类
    WorkThread              工作线程类
    TaskMonitorThread       任务监测线程类
    TaskTimeOutThread       任务超时监测线程类
  task
    TaskManager             任务管理器
    WorkTask                任务接口
    WorkTaskImp             正常任务类
    WorkTaskAImp            异常任务类
    WorkTaskBImp            超时任务类
  event
    AbstractEvent           任务事件类
    BeginTaskEvent          任务执行开始事件类
    EndTaskEvent            任务执行结束事件类
    TaskRunTime             任务运行时间类
    TaskTimeOutEvent        任务执行超时事件类
源代码
package test;
import task.TaskManager;
import task.WorkTask;
import task.WorkTaskAImp;
import task.WorkTaskBImp;
import task.WorkTaskImp;
import thread.ThreadPool;
/**
* 线程池测试类,测试功能如下：
* 1、测试线程池创建功能
* 2、测试处理并发请求功能
* 3、测试关闭功能
**/
public class TestThreadPool {
        public static void main(String[] args){
                //创建线程池,开启处理请求服务
                final int threadCount=10;
                ThreadPool pool=ThreadPool.getInstance();
                pool.init(threadCount);
                //接收客户端请求
                WorkTask task1=new WorkTaskBImp("执行超时任务...");
                TaskManager.addTask(task1);
                final int requestCount=20;
                for(int i=0;i threadlist=new Vector();//工作线程列表
        private TaskMonitorThread mainThread;//任务监测线程
        private TaskTimeOutThread timeThread; //任务超时线程
        private boolean StopGetIdleThread=false;
    //单例模式
        private ThreadPool(){
        }       
        public static synchronized ThreadPool getInstance(){
                return pool;
        }
        private void stopGetIdleThread(){
                StopGetIdleThread = true;
        }
        //初始化线程池
        public  void init(int count){
                System.out.println("开始初始化线程池...");
                threadcount=count;
                for(int i=0;i taskruntimelist=new Vector();//运行任务列表
        private int pollTime=500; //轮询时间
        private int TaskOutTime=2000; //任务过时时间
        public TaskTimeOutThread(ThreadPool pool){
                this.pool=pool;
        }
        @Override
        public void run() {
                // TODO Auto-generated method stub
                        while(!shutdown){
                                synchronized(taskruntimelist){
                                        for(int i=0;i0){
                        try {
                                Thread.sleep(pollTime);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
                shutdown=true;
        }
       
}
package task;
import java.util.ArrayList;
import java.util.List;
/**
*  任务管理器
*  1、添加任务
*  2、监测是否有新任务
*/
public class TaskManager {
        private  static List taskQueue=new ArrayList(); //任务队列
        private TaskManager(){
               
        }
        //添加任务                                            
        public synchronized static  void addTask(WorkTask task){
                taskQueue.add(task);
        }
        //判断是否有任务未执行
        public synchronized static WorkTask getWorkTask(){
                if (taskQueue.size()>0){
                        return (WorkTask)taskQueue.remove(0);
                }else
                        return null;
        }
}
package task;
/**
* 任务接口
* 继承它来定义自己具体的工作任务
*/
public interface WorkTask {
        void execute() throws Exception; //执行工作任务
        void setTaskThreadKey(Object key);//设置任务线程编号
}
package task;
/**
* 任务类1
* 正常执行的工作任务
*/
public class WorkTaskImp implements WorkTask {
        protected String param;
        protected Object threadkey; //为了显示执行线程编号
        protected final int TaskExecTime=500; //任务执行时间
        public void execute() throws Exception {
                // TODO Auto-generated method stub
                System.out.println(param+"工作线程编号"+threadkey.toString());
            Thread.sleep(TaskExecTime);
        }
        public WorkTaskImp(String param){
                this.param=param;
        }
        public void setTaskThreadKey(Object key){
                this.threadkey=key;
        }
        public String toString(){
                return param+"工作线程编号"+threadkey.toString();
        }
}
package task;
/**
* 任务类2
* 执行报异常的工作任务
*/
public class WorkTaskAImp extends WorkTaskImp{
        public WorkTaskAImp(String param) {
                super(param);
                // TODO Auto-generated constructor stub
        }
        public void execute() throws Exception {
                // TODO Auto-generated method stub
                throw new Exception("运行WorkTaskAImp任务时出错");
        }
}
package task;
/*
* 任务类3
* 执行超时的工作任务
*/
public class WorkTaskBImp extends WorkTaskImp{
        public WorkTaskBImp(String param) {
                super(param);
                // TODO Auto-generated constructor stub
        }
        public void execute() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("正在"+param);
            Thread.sleep(50000); //随便定义
        }
}
package event;
import task.WorkTask;
import thread.WorkThread;
/*
*任务抽象事件
*/
public abstract class AbstractEvent {
        protected WorkThread workthread;
        protected Thread nowthread;
        protected WorkTask nowtask;
        //事件触发
        public synchronized void execute(){};
        @Override
        public boolean equals(Object obj) {
                // TODO Auto-generated method stub
                AbstractEvent other=(AbstractEvent)obj;
                return this.workthread==other.workthread&&this.nowtask==this.nowtask;
        };
       
}
package event;
import task.WorkTask;
import thread.ThreadPool;
import thread.WorkThread;
/*
* 任务开始运行事件
*/
public class BeginTaskEvent extends AbstractEvent{
        public BeginTaskEvent(WorkThread workthread,Thread nowthread,WorkTask task){
                this.workthread=workthread;
                this.nowthread=nowthread;
                this.nowtask=task;
        }
        @Override
        public  void execute() {
                // TODO Auto-generated method stub
                ThreadPool pool=ThreadPool.getInstance();
                pool.beginTaskRun(this);
        }
}
package event;
import task.WorkTask;
import thread.ThreadPool;
import thread.WorkThread;
/*
* 任务运行结束事件
*/
public class EndTaskEvent extends AbstractEvent {
        public EndTaskEvent(WorkThread workthread,Thread nowthread,WorkTask task){
                this.workthread=workthread;
                this.nowthread=nowthread;
                this.nowtask=task;
        }
        @Override
        public  void execute() {
                // TODO Auto-generated method stub
                ThreadPool pool=ThreadPool.getInstance();
                pool.endTaskRun(this);
        }
       
}
package event;
/*
* 任务运行时间类
*/
public class TaskRunTime {
                private long begintime;
                private long endtime;
                private BeginTaskEvent event;
                public TaskRunTime(BeginTaskEvent event){
                        this.event=event;
                        this.begintime=System.currentTimeMillis();
                        this.endtime=this.begintime;
                }
                public BeginTaskEvent getEvent() {
                        return event;
                }
                //检查是否超时
                public boolean checkRunTimeOut(long maxtime){
                        endtime=System.currentTimeMillis();
                        long cha=endtime-begintime;
                        return cha>=maxtime;
                }
               
        }
package event;
import task.WorkTask;
import thread.ThreadPool;
import thread.WorkThread;
/*
* 任务超时事件
*/
public class TaskTimeOutEvent  {
        private AbstractEvent event;
        public TaskTimeOutEvent(AbstractEvent event){
                this.event=event;
        }
        @SuppressWarnings("deprecation")
        public  void execute() {
                // TODO Auto-generated method stub
                ThreadPool pool=ThreadPool.getInstance();
                pool.addWorkThread();
                pool.removeWorkThread(event.workthread);
                Object obj=event.workthread.getThreadKey();
                System.out.println("正在停止工作超时线程...线程编号"+obj);
                event.nowthread.stop();
               
        }
}
      
运行结果
开始初始化线程池...
正在创建工作线程...线程编号0
正在创建工作线程...线程编号1
正在创建工作线程...线程编号2
正在创建工作线程...线程编号3
正在创建工作线程...线程编号4
正在创建工作线程...线程编号5
正在创建工作线程...线程编号6
正在创建工作线程...线程编号7
正在创建工作线程...线程编号8
正在创建工作线程...线程编号9
正在创建任务监测线程...
结束初始化线程池...
正在执行超时任务1...
执行第0个增加用户操作...工作线程编号1
执行第1个增加用户操作...工作线程编号2
执行第2个增加用户操作...工作线程编号3
执行第3个增加用户操作...工作线程编号4
执行第4个增加用户操作...工作线程编号5
执行第5个增加用户操作...工作线程编号6
执行第6个增加用户操作...工作线程编号7
执行第7个增加用户操作...工作线程编号8
执行第8个增加用户操作...工作线程编号9
执行第9个增加用户操作...工作线程编号1
执行第10个增加用户操作...工作线程编号2
执行第11个增加用户操作...工作线程编号3
执行第12个增加用户操作...工作线程编号4
执行第13个增加用户操作...工作线程编号5
执行第14个增加用户操作...工作线程编号6
执行第15个增加用户操作...工作线程编号7
执行第16个增加用户操作...工作线程编号8
执行第17个增加用户操作...工作线程编号9
执行第18个增加用户操作...工作线程编号1
执行第19个增加用户操作...工作线程编号2
正在执行超时任务2...
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
执行第0个删除用户操作...工作线程编号4
执行第1个删除用户操作...工作线程编号5
执行第2个删除用户操作...工作线程编号6
执行第3个删除用户操作...工作线程编号7
执行第4个删除用户操作...工作线程编号8
执行第5个删除用户操作...工作线程编号9
执行第6个删除用户操作...工作线程编号1
执行第7个删除用户操作...工作线程编号2
执行第8个删除用户操作...工作线程编号4
执行第9个删除用户操作...工作线程编号5
执行第10个删除用户操作...工作线程编号6
执行第11个删除用户操作...工作线程编号7
执行第12个删除用户操作...工作线程编号8
执行第13个删除用户操作...工作线程编号9
正在关闭任务监测线程...
正在关闭超时监测线程...
正在创建工作线程...线程编号11
正在停止工作超时线程...线程编号0
正在创建工作线程...线程编号12
正在停止工作超时线程...线程编号3
正在关闭工作线程...线程编号1
正在关闭工作线程...线程编号2
正在关闭工作线程...线程编号4
正在关闭工作线程...线程编号5
正在关闭工作线程...线程编号6
正在关闭工作线程...线程编号7
正在关闭工作线程...线程编号8
正在关闭工作线程...线程编号9
正在关闭工作线程...线程编号11
正在关闭工作线程...线程编号12


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/86974/showart_2097658.html