手写线程池

package com.threadpool;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;

public class SimpleThreadPool extends Thread {
	//队列数
	private int queueSize;
	//当前线程数
	private int currentSize;
	//默认大小
	private static final int DEFAULT_SIZE = 4;
	//最大任务
	private static final int DEFAULT_QUEUE_SIZE = 30;
	//任务队列
	private static final LinkedList<Runnable> TASKQUEUE = new LinkedList<>();
	//工作队列
	private static final List<WorkThread> THREADQUEUE = new ArrayList<>();
	//拒绝策略
	private DiscardPolicy discardPolicy;
	//默认拒绝策略
	private static DiscardPolicy DEFAULT_POLICY = ()->{
		throw new RuntimeException("任务超出预期！");
	};
	//是否已关闭
	private boolean isDestroy = false;

	private int min;

	private int active;

	private int max;
	
	public SimpleThreadPool() {
		this(4,8,12,DEFAULT_QUEUE_SIZE,DEFAULT_POLICY);
	}
	
	public SimpleThreadPool(int min, int active, int max, int queueSize, DiscardPolicy discardPolicy) {
		this.min = min;
		this.active = active;
		this.max = max;
		this.currentSize = min;
		this.discardPolicy = discardPolicy;
		this.queueSize = queueSize;
	}
	
	//初始化
	public void init() {
		for (int i = 0; i < currentSize; i++) {
			createTask();
		}
	}
	
	public void createTask() {
		WorkThread workThread = new WorkThread();
		workThread.start();
		THREADQUEUE.add(workThread);
	}


	//线程状态
	private enum WorkerThreadState {
		FREE,BLOCK,RUNNING,DEAD
	}
	//任务提交
	public void submit(Runnable task) {
		if (isDestroy){
			throw new RuntimeException("线程池已关闭，不可再提交任务");
		}
		synchronized (TASKQUEUE) {
			//当前队列中的任务数超出预定的任务就拒绝
			if (TASKQUEUE.size() > queueSize) {
				System.out.println("当前任务队列中任务数："+TASKQUEUE.size());
				this.discardPolicy.discard();
			}
			TASKQUEUE.addLast(task);
			TASKQUEUE.notifyAll();
		}
	}

	public void shutDown() throws Exception {
		while (!TASKQUEUE.isEmpty()){
			Thread.sleep(500);
		}
		synchronized (THREADQUEUE){
			int threadSize = THREADQUEUE.size();
			while (threadSize > 0){
				for (WorkThread workThread : THREADQUEUE) {
					//线程状态不能为RUNNING
					//等待线程
					if (workThread.state == WorkerThreadState.BLOCK){
						workThread.interrupt();
						workThread.close();
						threadSize--;
					} /*else if (workThread.state == WorkerThreadState.FREE){
						workThread.close();
						threadSize--;
					}*/else {//线程还在running
						Thread.sleep(500);
					}
				}
			}
		}
		isDestroy = true;
		System.out.println("线程池已关闭");
	}
	
	//拒绝策略
	public interface DiscardPolicy {
		void discard();
	}

	@Override
	public void run() {
		while (!isDestroy){
			System.out.println("最小线程数："+min+",活动线程数："+active+",最大线程数："+max+"，当前线程数："+currentSize+",当前任务数："+TASKQUEUE.size());

			synchronized (THREADQUEUE){
				//扩容
				if (TASKQUEUE.size() > active && currentSize < active){
					for (int i = currentSize; i < active; i++) {
						createTask();
					}
					currentSize = active;
					System.out.println("线程池扩容到:"+active);
				} else if (TASKQUEUE.size() > max && currentSize < max){
					for (int i = currentSize; i < max; i++) {
						createTask();
					}
					currentSize = max;
					System.out.println("线程池扩容到:"+max);
				}

				//缩容
				if (TASKQUEUE.isEmpty() && currentSize > active){
					System.out.println("线程开始缩容");
					int releaseSize = currentSize - active;

					Iterator<WorkThread> iterator = THREADQUEUE.iterator();
					while (iterator.hasNext()){
						if (releaseSize <= 0){
							break;
						}

						WorkThread workThread = iterator.next();
						if (workThread.state == WorkerThreadState.BLOCK){
							workThread.interrupt();
							workThread.close();
							iterator.remove();
							releaseSize--;
							System.out.println("线程workThread.state="+workThread.state);
						}
					}
					currentSize = active;
				}
			}


			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	/**
	 *  线程池原理
	 * 1、定义一个队列，用来存放提交的任务
	 * 2、内部线程类操作任务队列
	 * 3、外部线程提交任务
	 *
	 * 拒绝策略
	 *任务队列中不可能无限制的增加任务，当任务达到一个阈值的时候，线程池得拒绝请求
	 *
	 * 关闭线程池
	 * 线程池在非RUNNING状态的时候，即BLOCK状态的时候才能够被关闭
	 *
	 * 线程池的扩容和缩容
	 *
	 */
	class WorkThread extends Thread{
		private volatile WorkerThreadState state = WorkerThreadState.FREE;
		@Override
		public void run() {
			OUTER:
			while(WorkerThreadState.DEAD != state) {
				Runnable task;
				synchronized (TASKQUEUE) {
					while(TASKQUEUE.isEmpty()) {
						try {
							this.state = WorkerThreadState.BLOCK;
							TASKQUEUE.wait();
						}catch (InterruptedException e) {
//							e.printStackTrace();
							System.out.println("线程interrupt and will be close");
							break OUTER;
						}
					}
					task = TASKQUEUE.remove();
					
				}
				if (task != null) {
					this.state = WorkerThreadState.RUNNING;
					task.run();
					this.state = WorkerThreadState.FREE;
				}
			}
		}

		public void close(){
			this.state = WorkerThreadState.DEAD;
		}

	}
	
	
	public static void main(String[] args) throws Exception {
		SimpleThreadPool simpleThreadPool = new SimpleThreadPool(5,10,15,66,SimpleThreadPool.DEFAULT_POLICY);
		simpleThreadPool.init();
		simpleThreadPool.start();
		IntStream.range(0, 50).forEach(i->{
			simpleThreadPool.submit(()->{
				try {
					Thread.sleep(1000);
					System.out.println(">>>>>>>>当前线程："+Thread.currentThread()+"处理任务"+i);
				}catch (Exception e) {
					e.printStackTrace();
				}
			});
		});
		Thread.sleep(10000);
		simpleThreadPool.shutDown();
		simpleThreadPool.submit(()-> System.out.println("再提交一个任务试试"));
	}

}