Java模拟线程池的实现

包中包含的类如下

Task.java

package me.ThreadPool;

/**
 * 任务类：
 * 		任务当前状态，
 * 		任务执行的方法
 * @author admin
 *
 */
public abstract class Task {
	public enum State{
		NEW,
		RUNNING,
		FINISHED
	}
	private State state=State.NEW;
	public State getState() {
		return state;
	}
	public void setState(State state) {
		this.state = state;
	}
	public abstract void deal();
}

TaskQueue.java

package me.ThreadPool;

import java.util.Iterator;
import java.util.LinkedList;
/**
 * 任务队列类：
 * 		新增移除任务
 * 		
 * @author admin
 *
 */
public class TaskQueue {
	private LinkedList<Task> queue=new LinkedList<>();
	
	public synchronized void addTask(Task task) {
		if(task !=null) {
			queue.add(task);
		}
	}
	public synchronized void finishTask(Task task) {
		if(task !=null) {
			task.setState(Task.State.FINISHED);
			queue.remove(task);
		}
	}
	public synchronized Task getTask() {
		Iterator<Task> it=queue.iterator();
		Task task = null;
		while(it.hasNext()) {
			task=it.next();
			if(Task.State.NEW.equals(task.getState())) {
				task.setState(Task.State.RUNNING);
			}
		}
		return task;
	}
}

TaskThread.java

package me.ThreadPool;
/**
 * 用于实现方法和任务绑定
 * @author admin
 *
 */
public class TaskThread extends Thread{
	private ThreadPoolService service;
	public TaskThread(ThreadPoolService service) {
		this.service=service;
	}
	@Override
	public void run() {
		while(service.isRunning()) {
			TaskQueue queue=service.getQueue();
			Task task=queue.getTask();
			if(task !=null) {
				task.deal();
			}
			queue.finishTask(task);
		}
	}
	
}

ThreadPoolService.java

package me.ThreadPool;

import java.util.LinkedList;
import java.util.List;
/**
 * 线程池类：
 * 		启动线程池服务，
 * 		管理线程，
 * 		设置任务队列状态
 * @author admin
 *
 */
public class ThreadPoolService {
	public enum State{
		NEW,
		RUNNING,
		TERMINATED
	}
	
	private final static int THREAD_COUNT=5;
	private State state=State.NEW;
	private List<Thread> threads=new LinkedList<Thread>();
	private TaskQueue queue=new TaskQueue(); 
	
	public void start() {
		this.setState(State.RUNNING);
		for(int i=0;i<THREAD_COUNT;i++) {
			threads.get(i).start();
		}
	}
	public ThreadPoolService() {
		for(int i=0;i<THREAD_COUNT;i++) {
			Thread t=new TaskThread(this);
			threads.add(t);
		}
	}
	public void stop() {
		this.setState(State.TERMINATED);
	}
	public void runTask(Task task) {
		queue.addTask(task);
	}
	public State getState() {
		return state;
	}
	public void setState(State state) {
		this.state = state;
	}
	public boolean isRunning() {
		return this.state==State.RUNNING;
	}
	public TaskQueue getQueue() {
		return queue;
	}
	public void setQueue(TaskQueue queue) {
		this.queue = queue;
	}
}

ThreadPoolTest.java

package me.ThreadPool;


public class ThreadPoolTest {
	public static void main(String[] args) throws InterruptedException {
		ThreadPoolService service=new ThreadPoolService();
		service.start();
		for(int i=0;i<10;i++) {
			service.runTask(new SimpleTask(i));
		}
		for(int i=0;i<10;i++) {
			service.runTask(new SimpleTask2(i));
		}
		Thread.sleep(5000);
		service.stop();
	}
}
class SimpleTask extends Task{
	
	private int i;
	public SimpleTask(int i) {
		this.i=i;
	}
	
	@Override
	public void deal() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName()+"simpleTask"+i);
	}
	
}
class SimpleTask2 extends Task{
	private int i;
	public SimpleTask2(int i) {
		this.i=i;
	}
	@Override
	public void deal() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName()+"simpleTask2"+i);
	}
	
}

运行结果：