实现一个简单线程池

package com.example;

import java.util.Deque;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Timer;
import java.util.TimerTask;

/**
 * Created by along on 2017/7/21.
 * 练习
 * 简单线程池的实现
 */

public class SimpleExecutor {

    //存储需要执行的任务 jdk 使用BlockingQueue
    private Deque<Runnable> mTaskQueue;
    //存储存活的工作线程
    private HashSet<PoolWorker> mWorkers;
    //存储空闲的工作线程
    private HashSet<PoolWorker> mFreeWorkers;
    //默认工作线程数量
    private int mWorkerCount;
    //最大工作线程数
    private int mMaxWorkerCount;
    //线程管理器
    private ThreadPool mThreadPool;

    SimpleExecutor(int maxWorkerCount) {
        this();
        mMaxWorkerCount = maxWorkerCount;
    }

    SimpleExecutor() {
        init();
    }

    private void init() {
        mWorkerCount = 5;
        mTaskQueue = new LinkedList<>();
        mWorkers = new HashSet<>();
        mFreeWorkers = new HashSet<>();
        mThreadPool = new ThreadPool();
    }

    /**
     * 加入任务 等待执行
     *
     * @param runnable
     */
    public void excute(Runnable runnable) {
        //任务加入队列
        mThreadPool.excute(runnable);
    }

    /**
     * 线程管理器
     */
    class ThreadPool {

        ThreadPool() {
            initWorker();  //初始化默认工作线程
            start();      //开启默认工作线程
            initTimer();  //初始化定时器，检查新任务，和空闲线程
        }

        private void initTimer() {
            //没1秒执行检查任务
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    //没有任务直接返回
                    if (mTaskQueue.isEmpty()) {
                        return;
                    }
                    //没有空闲线程，并且有新任务加入，则创建新的线程
                    if (mFreeWorkers.isEmpty() && !mTaskQueue.isEmpty()) {
                        addWorker();
                    }
                    //遍历空闲线程， 把任务加入空闲线程执行
                    Iterator<PoolWorker> it = mFreeWorkers.iterator();
                    while (it.hasNext()) {
                        if (mTaskQueue.isEmpty()) {
                            break;
                        }
                        PoolWorker next = it.next();
                        //添加未执行的任务
                        next.addTask(mTaskQueue.poll());
                        //中断等待中的线程，使之执行新任务
                        next.thread.interrupt();
                        //此线程不再是空闲线程，移除
                        it.remove();
                    }
                }
            }, 0, 100);
        }

        /**
         * 任务进栈
         *
         * @param runnable
         */
        public void excute(Runnable runnable) {
            mTaskQueue.offer(runnable);
        }

        /**
         * 初始化工作线程
         */
        private void initWorker() {
            //创建mWorkerCount个工作线程
            int i = 0;
            while (i < mWorkerCount) {
                i++;
                mWorkers.add(new PoolWorker());
            }
        }

        /**
         * 添加工作线程
         */
        private void addWorker() {
            //当前线程数小于最大线程数
            if (mWorkers.size() < mMaxWorkerCount) {
                PoolWorker work = new PoolWorker();
                work.thread.start();
                mWorkers.add(work);
            }
        }

        /**
         * 启动线程
         */
        private void start() {
            for (PoolWorker mWorker : mWorkers) {
                mWorker.thread.start();
            }
        }

    }

    /**
     * 工作线程
     */
    class PoolWorker implements Runnable {
        private boolean mIsAlive;  //线程是否存活
        private boolean mIsFree;  //线程是否空闲
        private Runnable mTask;  //任务
        //当前对象创建的线程
        public Thread thread;

        PoolWorker(Runnable task) {
            this();
            mTask = task;
        }

        PoolWorker() {
            thread = new Thread(this);
        }

        private void addTask(Runnable task) {
            this.mTask = task;
        }

        /**
         * 执行任务
         */
        @Override
        public void run() {
            while (true) {
                synchronized (this) {
                    //执行任务
                    if (mTask != null) {
                        mIsFree = false;
                        mTask.run();
                    }
                    //执行完任务线程继续等待
                    try {
                        mIsFree = true;
                        mFreeWorkers.add(this);
                        wait();
                    } catch (InterruptedException e) {
                        //Thread.currentThread().interrupt();
                    }
                }
            }
        }
    }

}

使用

public static void main(String[] args){
 SimpleExecutor simpleExecutor = new SimpleExecutor(9);
        simpleExecutor.excute(new Task());
        simpleExecutor.excute(new Task());
        simpleExecutor.excute(new Task());
}

 class Task implements Runnable {
        @Override
        public void run() {
            System.out.println("Task runing--- " + "Thread---" + Thread.currentThread());
        }
    }