手写一个线程池

前言

和设计模式一样，打算花三个月的时间，结合《Java并发编程实战》一书，来总结下并发方面的知识。第一章从线程池的原理开始总结，希望自己能坚持下来，加油！

1. 如何实现一个线程池？

线程池的概念这里不多说，在讲它的原理前，我们先自己想一下，如果我来写，那如何实现一个线程池？

1.1 线程池的重要变量

首先要定义一个存放所有线程的集合；
另外，每有一个任务分配给线程池，我们就从线程池中分配一个线程处理它。但当线程池中的线程都在运行状态，没有空闲线程时，我们还需要一个队列来存储提交给线程池的任务。

/**存放线程的集合*/
private ArrayList<MyThead> threads;
/**任务队列*/
private ArrayBlockingQueue<Runnable> taskQueue;

初始化一个线程池时，要指定这个线程池的大小；另外，我们还需要一个变量来保存已经运行的线程数目。

/**线程池初始限定大小*/
private int threadNum;
/**已经工作的线程数目*/
private int workThreadNum;

1.2 线程池的核心方法

线程池执行任务

接下来就是线程池的核心方法，每当向线程池提交一个任务时。如果 已经运行的线程<线程池大小，则创建一个线程运行任务，并把这个线程放入线程池；否则将任务放入缓冲队列中。

public void execute(Runnable runnable) {
    try {
        mainLock.lock();
        //线程池未满，每加入一个任务则开启一个线程
        if(workThreadNum < threadNum) {
            MyThead myThead = new MyThead(runnable);
            myThead.start();
            threads.add(myThead);
            workThreadNum++;
        }
        //线程池已满，放入任务队列，等待有空闲线程时执行
        else {
            //队列已满，无法添加时，拒绝任务
            if(!taskQueue.offer(runnable)) {
                rejectTask();
            }
        }
    } finally {
        mainLock.unlock();
    }
}

到这里，一个线程池已经实现的差不多了，我们还有最后一个难点要解决：从任务队列中取出任务，分配给线程池中“空闲”的线程完成。

分配任务给线程的第一种思路

很容易想到一种解决思路：额外开启一个线程，时刻监控线程池的线程空余情况，一旦有线程空余，则马上从任务队列取出任务，交付给空余线程完成。

这种思路理解起来很容易，但仔细思考，实现起来很麻烦（1. 如何检测到线程池中的空闲线程 2. 如何将任务交付给一个.start()运行状态中的空闲线程）。而且使线程池的架构变的更复杂和不优雅。

分配任务给线程的第二种思路

现在我们来讲第二种解决思路：线程池中的所有线程一直都是运行状态的，线程的空闲只是代表此刻它没有在执行任务而已；我们可以让运行中的线程，一旦没有执行任务时，就自己从队列中取任务来执行。

为了达到这种效果，我们要重写run方法，所以要写一个自定义Thread类，然后让线程池都放这个自定义线程类

class MyThead extends Thread {
    private Runnable task;

    public MyThead(Runnable runnable) {
        this.task = runnable;
    }
    
    @Override
    public void run() {
        //该线程一直启动着，不断从任务队列取出任务执行
        while (true) {
            //如果初始化任务不为空，则执行初始化任务
            if(task != null) {
                task.run();
                task = null;
            }
            //否则去任务队列取任务并执行
            else {
                Runnable queueTask = taskQueue.poll();
                if(queueTask != null)
                    queueTask.run();
            }
        }
    }
}

1.3 最后生成的简单线程池

/**
 * 自定义简单线程池
 */
public class MyThreadPool {
    /**存放线程的集合*/
    private ArrayList<MyThead> threads;
    /**任务队列*/
    private ArrayBlockingQueue<Runnable> taskQueue;
    /**线程池初始限定大小*/
    private int threadNum;
    /**已经工作的线程数目*/
    private int workThreadNum;

    private final ReentrantLock mainLock = new ReentrantLock();

    public MyThreadPool(int initPoolNum) {
        threadNum = initPoolNum;
        threads = new ArrayList<>(initPoolNum);
        //任务队列初始化为线程池线程数的四倍
        taskQueue = new ArrayBlockingQueue<>(initPoolNum * 4);

        threadNum = initPoolNum;
        workThreadNum = 0;
    }

    public void execute(Runnable runnable) {
        try {
            mainLock.lock();
            //线程池未满，每加入一个任务则开启一个线程
            if(workThreadNum < threadNum) {
                MyThead myThead = new MyThead(runnable);
                myThead.start();
                threads.add(myThead);
                workThreadNum++;
            }
            //线程池已满，放入任务队列，等待有空闲线程时执行
            else {
                //队列已满，无法添加时，拒绝任务
                if(!taskQueue.offer(runnable)) {
                    rejectTask();
                }
            }
        } finally {
            mainLock.unlock();
        }
    }

    private void rejectTask() {
        System.out.println("任务队列已满，无法继续添加，请扩大您的初始化线程池！");
    }
    public static void main(String[] args) {
        MyThreadPool myThreadPool = new MyThreadPool(5);
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行中");
            }
        };

        for (int i = 0; i < 20; i++) {
            myThreadPool.execute(task);
        }
    }

    class MyThead extends Thread {
        private Runnable task;

        public MyThead(Runnable runnable) {
            this.task = runnable;
        }
        @Override
        public void run() {
            //该线程一直启动着，不断从任务队列取出任务执行
            while (true) {
                //如果初始化任务不为空，则执行初始化任务
                if(task != null) {
                    task.run();
                    task = null;
                }
                //否则去任务队列取任务并执行
                else {
                    Runnable queueTask = taskQueue.poll();
                    if(queueTask != null)
                        queueTask.run();
                }
            }
        }
    }
}

现在我们来总结一下，这个自定义线程池的整个工作过程：

1. 初始化线程池，指定线程池的大小。
2. 向线程池中放入任务执行。
3. 如果线程池中创建的线程数目未到指定大小，则创建我们自定义的线程类放入线程池集合，并执行任务。执行完了后该线程会一直监听队列
4. 如果线程池中创建的线程数目已满，则将任务放入缓冲任务队列
5. 线程池中所有创建的线程，都会一直从缓存任务队列中取任务，取到任务马上执行