Java线程池实现例子

这是我从网上裆下来的一个线程池例子,因为是菜鸟，也是看了有一会儿才看懂了，希望能帮到其他的菜鸟们;

说下实现思路:

PoolManager:创建了一个ArrayList用来存放实例化好的线程对象:一个线程可以帮助一个任务去执行：工厂

Worker:也就是工人的意思:就是实例化好的线程，放到了线程池工厂里，有一批新货（任务）就找一个空闲的线程(工人)去做这件事：工厂里的工人

TaskManager:任务（新货）需要放到一个临时的仓库:这个类就是这个仓库：接到任务的工人从这个仓库里拿需要执行的任务:需要干的活的仓库

TaskNibutirThread:哪件事情由那个人去做，仓库里有没有货，工厂里有没有闲着的工人，都是这个类负责的:负责分配任务的主管

WorkTask:任务的接口其他的是它的实现类，用来放到仓库里执行的

package com.threadpool;

import java.util.ArrayList;

/*

* 线程池管理器（PoolManager）:用于创建并管理线程池，采用单例模式

*

*/

public class PoolManager {

public static PoolManager mPool=new PoolManager();

public final int max_pool =3;

public final int max_Tasks = 15;

public static ArrayList init_pools;

// private int GetIdleThreadPollTime=50;//获取空闲线程轮询间隔时间,可配置

private TaskMonitorThread mainThread;//任务监测线程

static {

init_pools = new ArrayList(5);

}

public static PoolManager getInstance() {

if (mPool == null) {

mPool = new PoolManager();

}

return mPool;

}

//获取空闲线程

public Worker getIdleThread(){

Worker working =null;

while(true){

synchronized(init_pools){

for (int i = 0; i < max_pool; i++) {

//Worker working = init_pools.get(i);

working = init_pools.get(i);

if (!working.isrunning) {

// System.out.println("工作将由闲置线程" + working.getThreadTag() + "执行");

return working;

}

}

}

try {

Thread.sleep(5000);//放弃CPU,若干时间后重新获取空闲线程

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

public void init() {

System.out.println("线程池初始化开始。。。");

Worker worker = null;

for (int i = 0; i < this.max_pool; i++) {

worker = new Worker("initThread"+i);

init_pools.add(worker);

worker.start();

}

mainThread=new TaskMonitorThread();

mainThread.start();

System.out.println("结束初始化线程池...");

}

public void destory(){

init_pools.clear();

}

}

package com.threadpool;

import java.util.LinkedList;

/**

* 任务管理器

* 1、添加任务

* 2、监测是否有新任务

*/

public class TaskManager {

public static LinkedList workqueue =new LinkedList();// 缓冲队列

/**

* 向工作队列中加入一个任务，由工作线程去执行该任务

*

* @param task

*/

public synchronized static void addTask(WorkTask worktask) {

if (worktask != null &&workqueue.size()<15) {

workqueue.add(worktask);

}

}

/*[com.yulin.threadpool.WorkTaskImp@44f4ac30,

com.yulin.threadpool.WorkTaskImp@44f4ad60,

com.yulin.threadpool.WorkTaskImp@44f4ae00,

com.yulin.threadpool.WorkTaskImp@44f4aea0,

com.yulin.threadpool.WorkTaskImp@44f4af40]*/

/**

* 从工作队列中取出一个任务

*

* @return

* @throws InterruptedException

*/

public synchronized static WorkTask getTask() throws InterruptedException { while (workqueue.size() >0) {

return (WorkTask) workqueue.removeFirst();

}

return null;

}

}

package com.threadpool;

public final class TaskMonitorThread extends Thread {

//private PoolManage threadPool;

private int GetWorkTaskPollTime = 10;// 监测任务轮询时间，可配置

/*public TaskMonitorThread(PoolManage pool) {

System.out.println("正在创建任务监测线程...");

this.threadPool = pool;

}*/

public TaskMonitorThread() {

System.out.println("正在创建任务监测线程...");

}

@Override

public void run() {

// TODO Auto-generated method stub

while (true) {

try {

WorkTask task = TaskManager.getTask();

if (task == null) {

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

} else {

Worker t = PoolManager.getInstance().getIdleThread();// 获取空闲线程

System.out.println("Worker.toString()=============================>?"+t.toString());

if (t == null)

break;

t.setWorkTask(task);// 设置线程任务

System.out.println("task.toString()=============================>?"+task.toString());

t.setIsRunning(true);//激活空闲线程

System.out.println("Worker.toString()=============================>?"+t.getIsrunning( ));

// try {

//Thread.sleep(GetWorkTaskPollTime);

//

}

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

package com.threadpool;

/**

* 线程池测试类,测试功能如下：

* 1、测试线程池创建功能

* 2、测试处理并发请求功能

* 3、测试关闭功能

**/

public class TestThreadPool {

public static void main(String[] args){

//创建线程池,开启处理请求服务

PoolManager pool=PoolManager.getInstance();

pool.init();

//接收客户端请求

WorkTask task1=new WorkTaskAImp("执行超时任务1...");

TaskManager.addTask(task1);

final int requestCount=15;

for(int i=0;i

WorkTask task=new WorkTaskImp("执行第"+i+"个增加用户操作.....");

TaskManager.addTask(task);

}

/**/

}

}

package com.threadpool;

/**

* 工作线程（WorkThread）: 线程池中线程

* @author yulin

*

*/

public class Worker extends Thread {

public boolean isrunning=false;

private WorkTask nowTask; // 当前任务

private Object threadTag;// 线程标识

//获取线程标识key

public Object getThreadTag() {

return threadTag;

}

public synchronized void setWorkTask(WorkTask task) {

this.nowTask = task;

}

public synchronized void setIsRunning(boolean flag) {

this.isrunning = flag;

if (flag) {

this.notify();

}

}

public Worker(Object key) {

System.out.println("正在创建工作线程...线程编号" + key.toString());

this.threadTag = key;

// this.state=CREA TESTA TE;

}

public boolean getIsrunning() {

return isrunning;

}

public synchronized void run() {

System.out.println("工作线程" + this.getThreadTag() + "初始化成功");

while (true) {

if (!isrunning) {

try {

System.out.println("工人" + this.getThreadTag() + "任务完成回归线程池");

this.wait();

} catch (InterruptedException e) {

System.out.println("线程被阻挡");

e.printStackTrace();

}

} else {

//try {

nowTask.runTask();

setIsRunning(false);

System.out.println("工人" +this.getThreadTag() + "开始工作");

//this.sleep(3000);

//} catch (InterruptedException e) {

// e.printStackTrace();

//}

//this.notify();

//break;

}

}

}

}

package com.threadpool;

public interface WorkTask {

public void runTask();//执行工作任务

//public int compareTo(mJob job);

public void cancelTask();

public int getProgress();

}

package com.threadpool;

/**

* 任务类1

* 正常执行的工作任务

*/

public class WorkTaskAImp implements WorkTask {

protected String param;

public WorkTaskAImp(){

}

public WorkTaskAImp(String param){

this.param=param;

}

@Override

public void runTask() {

// TODO Auto-generated method stub

// Log.v("=============>Task1", this.param);

System.out.println("=============>Task1"+this.param);

}

@Override

public void cancelTask() {

// TODO Auto-generated method stub

}

@Override

public int getProgress() {

// TODO Auto-generated method stub

return 0;

}

}

package com.threadpool;

/**

* 任务类1

* 正常执行的工作任务

*/

public class WorkTaskImp implements WorkTask {

protected String param;

public WorkTaskImp(){

}

public WorkTaskImp(String param){

this.param=param;

}

@Override

public void runTask() {

// TODO Auto-generated method stub

System.out.println("=============>Task0"+this.param);

}

@Override

public void cancelTask() {

// TODO Auto-generated method stub

}

@Override

public int getProgress() {

// TODO Auto-generated method stub

return 0;

}

}