简单线程池的实现

为此我们定义了四个类，它们的用途及具体实现如下：

• Task（任务）：这是个代表任务的抽象类，其中定义了一个deal()方法，继承Task抽象类的子类需要实现这个方法，并把这个任务需要完成的具体工作在deal()方法编码实现。线程池中的线程之所以被创建，就是为了执行各种各样数量繁多的任务的，为了方便线程对任务的处理，我们需要用Task抽象类来保证任务的具体工作统一放在deal()方法里来完成，这样也使代码更加规范。

Task的定义如下：

public abstract class Task {
    public enum State {
        /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED
    }
    // 任务状态
    private State state = State.NEW;

    public void setState(State state) {
        this.state = state;
    }
    public State getState() {
        return state;
    }
    public abstract void deal();
}

• TaskQueue（任务队列）：在同一时刻，可能有很多任务需要执行，而程序在同一时刻只能执行一定数量的任务，当需要执行的任务数超过了程序所能承受的任务数时怎么办呢？这就有了先执行哪些任务，后执行哪些任务的规则。TaskQueue类就定义了这些规则中的一种，它采用的是FIFO（先进先出，英文名是First In First Out）的方式，也就是按照任务到达的先后顺序执行。

TaskQueue类的定义如下：

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

public class TaskQueue {
    private List<TaskQueue> queue = new LinkedList<TaskQueue>();

    // 添加一项任务
    public synchronized void addTask(TaskQueue task) {
        if (task != null) {
            queue.add(task);
        }
    }

    // 完成任务后将它从任务队列中删除
    public synchronized void finishTask(TaskQueue task) {
        if (task != null) {
            task.setState(TaskQueue.State.FINISHED);
            queue.remove(task);
        }
    }

    // 取得一项待执行任务
    public synchronized TaskQueue getTask() {
        Iterator<TaskQueue> it = queue.iterator();
        TaskQueue task;
        while (it.hasNext()) {
            task = it.next();
            // 寻找一个新建的任务
            if (TaskQueue.State.NEW.equals(task.getState())) {
                // 把任务状态置为运行中
                task.setState(TaskQueue.State.RUNNING);
                return task;
            }
        }
        return null;
    }
}

addTask(Task task)方法用于当一个新的任务到达时，将它添加到任务队列中。这里使用了LinkedList 类来保存任务到达的先后顺序。finishTask(Task task)方法用于任务被执行完毕时，将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。

• TaskThread（执行任务的线程）：它继承自Thread类，专门用于执行任务队列中的待执行任务。

public class TaskThread extends Thread {
    // 该线程所属的线程池
    private ThreadPoolService service;

    public TaskThread(ThreadPoolService tps) {
        service = tps;
    }

    public void run() {
        // 在线程池运行的状态下执行任务队列中的任务
        while (service.isRunning()) {
            TaskQueue queue = service.getTaskQueue();
            Task task = queue.getTask();
            if (task != null) {
                task.deal();
            }
            queue.finishTask(task);
        }
    }
}

• ThreadPoolService（线程池服务类）：这是线程池最核心的一个类。它在被创建了时候就创建了几个线程对象，但是这些线程并没有启动运行，但调用了start()方法启动线程池服务时，它们才真正运行。stop()方法可以停止线程池服务，同时停止池中所有线程的运行。而runTask(Task task)方法是将一个新的待执行任务交与线程池来运行。

ThreadPoolService类的定义如下：

import java.util.ArrayList;
import java.util.List;

public class ThreadPoolService {
    // 线程数
    public static final int THREAD_COUNT = 5;
    // 线程池状态
    private Status status = Status.NEW;
    private TaskQueue queue = new TaskQueue();

    public enum Status {
        /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,
    }

    private List<Thread> threads = new ArrayList<Thread>();

    public ThreadPoolService() {
        for (int i = 0; i < THREAD_COUNT; i++) {
            Thread t = new TaskThread(this);
            threads.add(t);
        }
    }

    // 启动服务
    public void start() {
        this.status = Status.RUNNING;
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads.get(i).start();
        }
    }

    // 停止服务
    public void stop() {
        this.status = Status.TERMINATED;
    }

    // 是否正在运行
    public boolean isRunning() {
        return status == Status.RUNNING;
    }

    // 执行任务
    public void runTask(Task task) {
        queue.addTask(task);
    }

    protected TaskQueue getTaskQueue() {
        return queue;
    }
}

完成了上面四个类，我们就实现了一个简单的线程池。现在我们就可以使用它了，下面的代码做了一个简单的示例：

public class SimpleTaskTest extends Task {
    @Override 
    public void deal() {// do something }

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolService service = new ThreadPoolService();
        service.start();
        // 执行十次任务
        for (int i = 0; i < 10; i++) {
            service.runTask(new SimpleTaskTest());
        }
        // 睡眠1秒钟，等待所有任务执行完毕
        Thread.sleep(1000);
        service.stop();
    }
}

当然，我们实现的是最简单的，这里只是为了演示线程池的实现原理。在实际应用中，根据情况的不同，可以做很多优化。比如：

◦ 调整任务队列的规则，给任务设置优先级，级别高的任务优先执行。

◦ 动态维护线程池，当待执行任务数量较多时，增加线程的数量，加快任务的执行速度；当任务较少时，回收一部分长期闲置的线程，减少对系统资源的消耗。