java实现线程池

参考的博客：http://www.cnblogs.com/hustcat/archive/2008/10/10/1308425.html

package com.mhc.simulate;

import java.util.ArrayList;

public class ThreadPoolManager {

private ArrayList threads;//保存线程

private int maxThreadCount;//最大线程数

public ThreadPoolManager(){

this(10);//默认10个线程

}

public ThreadPoolManager(int maxThreadCount){

this.maxThreadCount = maxThreadCount;

threads = new ArrayList();

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

SimpleThread thread = new SimpleThread(i);

threads.add(thread);

thread.start();

}

System.out.println("thread pool created");

}

//处理一个任务

public void ProcessTask(Task task){

SimpleThread thread = getIdleThread();

if(thread!=null){

thread.setArgument(task);

thread.setRunningFlag(true);

}else{

System.out.println("没有空闲线程！");

}

}

//获取一个空闲线程

private synchronized SimpleThread getIdleThread(){

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

SimpleThread thread = (SimpleThread)threads.get(i);

if(!thread.isRunning()){

return thread;

}

}

return null;

}

}

package com.mhc.simulate;

/**

* @author mhc

*

*/

public class SimpleThread extends Thread{

private boolean runningFlag;//线程状态

private Task argument;//一个任务

public SimpleThread(int num){

this.runningFlag = false;

System.out.println("thread "+num+" starting!");

}

//线程执行

public Task getArgument() {

return argument;

}

public void setArgument(Task argument) {

this.argument = argument;

}

public synchronized void run(){

try {

while(true){

if(!runningFlag){

this.wait();//睡眠

}else{

System.out.println("processing "+argument.toString());

sleep(3000);//阻塞3秒

System.out.println(argument.toString()+" processed");

setRunningFlag(false);

}

}

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public boolean isRunning() {

return runningFlag;

}

public synchronized void setRunningFlag(boolean flag){

this.runningFlag = flag;

if(runningFlag){

this.notify();//唤醒线程 notify用在sychronized块里面，调用后不是立即释放对象锁的，而是在synchronized

//块结束后释放的

}

}

}

package com.mhc.simulate;

public class Task {

private String name;//任务名称

public Task(String name){

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String toString(){

return this.name;

}

}

package com.mhc.simulate;

public class TestThreadPool {

public static void main(String[] args) {

try {

ThreadPoolManager manager = new ThreadPoolManager();//生成线程池

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

Task task = new Task("task"+i);

manager.ProcessTask(task);//处理任务

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

模拟线程池的实现

进程，线程是现代操作系统两个比较重要的概念。正是由于它们的存在，使得程序和并发执行得以实现。

通常，即使有多线程，当线程数量太大时，不断的创建线程也会影响系统的性能，这时，我们可以创建线程池来达到

重用线程的目的，从而尽可能减小开销，大大提高系统的性能，比如很多网络爬虫上就使用了线程池。

这个包里是一个简单的线程池的实现（java实现）

这个 是由4个类构成，TestThreadPool测试线程池的类，用来模拟客户端的请求。它会创建20个任务（Task），交给

线程池（ThreadPoolManager)处理。线程池默认维护10个线程，当客户端请求一个任务时，他会获取一个空闲线程，

然后处理交给该线程（SimpleThread）处理。