线程池

public ThreadPoolExecutor(int corePoolSize,
						  int maximumPoolSize,
						  long keepAliveTime,
						  TimeUnit unit,
						  BlockingQueue<Runnable> workQueue,
						  ThreadFactory threadFactory,
						  RejectedExecutionHandler handler) {
	// 线程池大小不能小于0 || 最大容量不能小于0 || 最大容量不能小于线程池大小 || keepAliveTime不能小于0					  
	if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0)
		throw new IllegalArgumentException();
	if (workQueue == null || threadFactory == null || handler == null)
		throw new NullPointerException();
	// 初始化相应的属性数据	
	this.acc = System.getSecurityManager() == null ? null : AccessController.getContext();
	this.corePoolSize = corePoolSize;
	this.maximumPoolSize = maximumPoolSize;
	this.workQueue = workQueue;
	this.keepAliveTime = unit.toNanos(keepAliveTime);
	this.threadFactory = threadFactory;
	this.handler = handler;
}

threadsPool.execute(new Runnable() {
    @Override
    public void run() {
    // TODO Auto-generated method stub
    }
})

Future<Object> future = executor.submit(harReturnValuetask);
try {
    Object s = future.get();
} catch (InterruptedException e) {
    // 处理中断异常
} catch (ExecutionException e) {
    // 处理无法执行任务异常
} finally {
    // 关闭线程池
    executor.shutdown();
}

protected void beforeExecute(Thread t, Runnable r) { }

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    // 如果线程数小于基本线程数,则创建线程并执行当前任务
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
        // 如线程数大于等于基本线程数或线程创建失败,则将当前任务放到工作队列中
        if (runState == RUNNING && workQueue.offer(command)) {
            if (runState != RUNNING || poolSize == 0)
                ensureQueuedTaskHandled(command);
        }
        
        // 如果线程池不处于运行中或任务无法放入队列,并且当前线程数量小于最大允许的线程数量,则创建一个线程执行任务
        else if (!addIfUnderMaximumPoolSize(command))
            // 抛出RejectedExecutionException异常
            reject(command); // is shutdown or saturated
    }
}

public void run() {
    try {
        Runnable task = firstTask;
        firstTask = null;
        while (task != null || (task = getTask()) != null) {
            runTask(task);task = null;
        }
    } finally {
        workerDone(this);
    }
}

public class DolphinThreadPoolExecutor {
    private final BlockingQueue<Runnable> workQueue;// 待执行的任务,相当于任务缓冲区,其实例对象有ArrayBlockingQueue,LinkedBlockingQueue等

    private final ReentrantLock mainLock = new ReentrantLock();
    private final HashSet<Worker> workers = new HashSet<Worker>();// 线程池中的执行线程

    private int corePoolSize;// 初始化的线程的个数
    private int maxPoolSize;// 线程池的最大个数,当corePoolSize满了,而且BlockingQueue缓冲队列也满了,则初始化额外的线程,如果额外的线程达到上限,则任务丢弃

    private int workPoolSize;// 正在工作的线程
    private final boolean allowCoreThreadTimeOut;
    private final long keepAliveTime;
    private final TimeUnit timeUnit;

    public DolphinThreadPoolExecutor(int corePoolSize, int maxPoolSize, boolean allowCoreThreadTimeOut,
                                     long keepAliveTime, TimeUnit timeUnit, BlockingQueue<Runnable> workQueue) {
        this.workQueue = workQueue;
        this.corePoolSize = corePoolSize;
        this.maxPoolSize = maxPoolSize;
        this.allowCoreThreadTimeOut = allowCoreThreadTimeOut;
        this.keepAliveTime = keepAliveTime;
        this.timeUnit = timeUnit;
    }

    public DolphinThreadPoolExecutor(BlockingQueue<Runnable> workQueue, int corePoolSize, int maxPoolSize) {
        this(corePoolSize, maxPoolSize, false, 0L, TimeUnit.SECONDS, workQueue);
    }

    public void execute(Runnable task) {
        if (task == null) {
            throw new IllegalArgumentException("The parameter is not null");
        }

        Worker work = null;
        mainLock.lock();

        // 创建线程进行执行
        if (workPoolSize < corePoolSize) {
            work = new Worker(task);
        // 放到缓存队列中
        } else if (!workQueue.offer(task)) {
            // 开启额外的线程的进行执行
            if (workPoolSize < maxPoolSize) {
                work = new Worker(task);
            } else {
                throw new RuntimeException("The task was thowed");// 任务的抛弃策略，这里使用抛出异常，即这个任务无法处理
            }
        }

        if (work != null) {
            workers.add(work);
            work.t.start();
            workPoolSize++;
        }

        mainLock.unlock();
    }

    public void shutDownNow(){
        for(Worker w : workers){
            w.t.stop();
        }
    }

    private class Worker implements Runnable {
        private Runnable firstTask;
        private Thread t;

        private boolean state;//0:空闲 1：代表忙碌

        public Worker(Runnable firstTask) {
            super();
            this.firstTask = firstTask;
            this.t = new Thread(this);
        }

        @Override
        public void run() {
            runWorker(this);
        }

        private void runWorker(Worker w) {
            Runnable task = w.firstTask;
            w.firstTask = null;
            while (task != null || (task = getTask()) != null) {
                task.run();
                task=null;
            }
        }

        private Runnable getTask() {
            boolean timeOut;
            timeOut = allowCoreThreadTimeOut || workPoolSize > corePoolSize;

            try {
                // 如果是该线程长期存活，那么使用take线程阻塞的函数，如果是一旦没有任务就销毁线程，1.是核心线程
                // 2.线程数大于核心线程，即目前任务不多,线程多余
                Runnable task = timeOut ? workQueue.poll(keepAliveTime, timeUnit) : workQueue.take();
                if (task != null) {
                    return task;
                } else {
                    // 如果没有任务被获取,则这个线程即将被销毁
                    mainLock.lock();
                    workPoolSize--;
                    mainLock.unlock();
                    System.out.println("当前线程被销毁");
                    workers.remove(this);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
}

public class MyTask implements Runnable{
    private int taskNum;

    public MyTask(int taskNum) {
        super();
        this.taskNum = taskNum;
    }

    @Override
    public void run() {
        System.out.println("正在执行:"+taskNum+"任务");
        try {
            Thread.sleep(1000);
            System.out.println("任务"+taskNum+"結束");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

public class DolphinThreadPoolExecutorTest {
    public static void main(String[] args) throws InterruptedException {
        DolphinThreadPoolExecutor executor=new DolphinThreadPoolExecutor(2, 6, true, 100, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(4));
        for(int i=0;i<10;i++){
            Thread.sleep(100);
            executor.execute(new MyTask(i));
        }
    }
}