Java线程池的实现

线程池的作用：

一个线程的周期分为：创建、运行、销毁三个阶段。

处理一个任务时，首先创建一个任务线程，然后执行任务，完了还要销毁线程。而线程只有处于运行状态的时候，才是真的在处理我们交给它的任务，这个阶段才是有效运行时间。

所以，我们希望花在创建和销毁线程的资源越少越好。如果不销毁线程，而这个线程又不能被其他的任务调用，那么就会出现资源的浪费。为了提高效率，减少创建和销毁线程带来时间和空间上的浪费，出现了线程池技术。这种技术是在开始就创建一定量的线程，批量处理一类任务，等待任务的到来。任务执行完毕后，线程又可以执行其他的任务。等不再需要线程的时候，就销毁。这样就省去了频繁创建和销毁线程的麻烦。

1. 线程池类

import java.util.LinkedList;
import java.util.List;
 
public class MyThreadPool {
    // 线程池中默认线程的个数为5个
    private static int worker_num = 5;
    // 工作的线程
    private WorkThread[] workThreads;
    // 未处理的任务
    private static volatile int finished_task = 0;
    // 任务队列，作为一个缓冲，List线程不安全所以需要在使用的过程中对它进行同步。
    private List<Runnable> taskQueue = new LinkedList<Runnable>();
 
    // 单例模式
    private static MyThreadPool threadPool;
    // 私有化构造方法
    private MyThreadPool(){
        this(5);
    }
    // 创建线程池，num为线程池工作线程的个数
    private MyThreadPool(int num) {
        MyThreadPool.worker_num = num;
        workThreads = new WorkThread[num];
        for (int i = 0; i < num; i++) {
            workThreads[i] = new WorkThread();
            workThreads[i].start();
        }
    }
 
    // 获得一个线程池,默认线程数
    public static MyThreadPool getThreadPool(){
        return getThreadPool(MyThreadPool.worker_num);
    }
    // 单例模式，获得一个线程池
    public static MyThreadPool getThreadPool(int num) {
        if(num <= 0){
            num = MyThreadPool.worker_num;
        }
        if(threadPool == null){
            synchronized(MyThreadPool.class){
                if(threadPool == null)
                    threadPool = new MyThreadPool(num);
            }
        }
        return threadPool;
    }
 
    /**
     * 执行任务
     * 将该任务加入到任务队列的末尾，等待工作线程的调度
     * @param task
     */
    public void execute(Runnable task){
        synchronized (taskQueue){
            taskQueue.add(task);
            taskQueue.notify();
        }
    }
 
    /**
     * 批量执行任务
     * 将任务放到任务队列的末尾，等待工作线程的调度
     * @param task
     */
    public void execute(Runnable[] task){
        synchronized (taskQueue){
            for (Runnable runnable : task) {
                taskQueue.add(runnable);
            }
            taskQueue.notify();
        }
    }
 
    /**
     * 批量执行任务
     * 将任务放到任务队列的末尾，等待工作线程的调度
     * @param task
     */
    public void execute(List<Runnable> task){
        synchronized (taskQueue){
            for (Runnable runnable : task) {
                taskQueue.add(runnable);
            }
            taskQueue.notify();
        }
    }
 
    /**
     * 销毁线程池
     * 在所有任务都完成的情况下才销毁所有线程，否则等待任务队列的任务全部完成才销毁
     */
    public void destroy(){
        while(!taskQueue.isEmpty()){// 如果还有任务没执行完成，就等会再看看
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
 
        // 工作线程停止工作，且置为null
        for (int i = 0; i < MyThreadPool.worker_num; i++) {
            workThreads[i].stopWorker();
            workThreads[i] = null;
        }
        threadPool = null;
        taskQueue.clear();
    }
 
    // 返回工作线程的个数
    public int getWorkThreadNumber() {
        return worker_num;
    }
 
    // 返回已完成任务的个数
    public int getFinishedTaskNumber(){
        return finished_task;
    }
 
    // 返回任务队列的长度，即还没处理的任务个数
    public int getWaitTaskNumber(){
        return taskQueue.size();
    }
 
    // 覆盖toString方法，返回线程池信息：工作线程个数和已完成任务个数
    @Override
    public String toString() {
        return "WorkThread number:" + worker_num + "  finished task number:"
                + finished_task + "  wait task number:" + getWaitTaskNumber();
    }
 
    /**
     * 内部类，工作线程用来执行任务线程
     * @author liu
     *
     */
    private class WorkThread extends Thread{
        // 该工作线程是否有效，用于自然结束该工作线程
        private boolean isRunning = true;
 
        /*
         * 工作线程的关键之处，如果任务队列不空，则取出任务执行，若任务队列空，则等待。直到任务队列有任务时才取出执行
         */
        @Override
        public void run() {
            Runnable r = null;
            while( isRunning ){// 队列为空
                synchronized (taskQueue){
                    while(isRunning && taskQueue.isEmpty()){
                        try {
                            taskQueue.wait(20);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
 
                    if(!taskQueue.isEmpty()){
                        // 取出任务
                        r = taskQueue.remove(0);
                    }
                }
 
                if(r != null){
                    r.run();
                    // 完成的任务加一
                    finished_task += 1;
                }
 
                r = null;
            }
        }
 
        // 停止工作，让该线程自然执行完run方法，自然结束
        public void stopWorker() {
            this.isRunning = false;
        }
 
    }
}

2. 测试代码

public class TestThreadPool {
 
    public static void main(String[] args) {
        // 创建5个线程的线程池
        MyThreadPool t = MyThreadPool.getThreadPool(5);
        Runnable[] r = new Runnable[] { new Task(), new Task(), new Task()};
        t.execute(r);
        r = new Runnable[] {new Task(), new Task(), new Task()};
        t.execute(r);
        System.out.println(t);
        t.destroy();// 所有线程都执行完成才destory
        System.out.println(t);
    }
 
    // 任务类
    static class Task implements Runnable {
        private static volatile int i = 1;
 
        @Override
        public void run() {// 执行任务
            System.out.println("任务 " + (i++) + " 完成");
        }
    }
}

3. 运行结果

aaarticlea/png;base64,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" alt="" />

注：参照网上的代码和思路，通过自己的修改和调试完成