public ThreadPoolExecutor(
	int corePoolSize,					//核心線程數(shù)量：如果當(dāng)前運行的線程數(shù)量沒有達(dá)到 corePoolSize，則新建一個線程，否則加入到任務(wù)隊列中
	int maximumPoolSize,				//最大線程數(shù)：當(dāng)前系統(tǒng)最多存在的線程數(shù)
	long keepAliveTime,					//最大空閑時間：線程空閑的最大時間，超出時間該線程會銷毀；設(shè)置allowCodeThreadTimeOut（true/false）,可控制核心線程是否銷毀，默認(rèn)false 表示允許核心線程即使超過最大線程時間也不會銷毀
	TimeUnit unit,						//時間單位：	線程空閑的最大時間的單位
	BlockingQueue<Runnable> workQueue,	//任務(wù)隊列：	核心線程數(shù)量滿了之后，提交的任務(wù)加入到隊列中，等待核心線程數(shù)減少后再去創(chuàng)建線程；當(dāng)任務(wù)隊列已滿，但沒有達(dá)到最大線程數(shù)時，則新建非核心線程
	ThreadFactory threadFactory,		//線程工廠：	自定義線程的創(chuàng)建
	RejectedExecutionHandler handler	//飽和處理機(jī)制：當(dāng)任務(wù)隊列已滿且達(dá)到最大線程數(shù)時，采取的措施
)	

ThreadPoolExecutor(int corePoolSize,
                   int maximumPoolSize,
                   long keepAliveTime,
                   TimeUnit unit,
                   BlockingQueue<Runnable> workQueue)

public class MyTask implements Runnable{
	//任務(wù)id
	private int id;
	public MyTask(int id){
	    this.id=id;
	}
	@Override
	public void run() {
	    String name=Thread.currentThread().getName();
	    System.out.println("線程："+name+"-->即將執(zhí)行任務(wù)"+id);
	    try {
	        Thread.sleep(200);
	    } catch (InterruptedException e) {
	        e.printStackTrace();
	    }
	    System.out.println("線程:"+name+"執(zhí)行完成"+id);
	}
	@Override
	public String toString() {
	    return "MyTask{" +
	            "id=" + id +
	            '}';
	}
}

public class MyThread extends  Thread{
    private List<Runnable> tasks;
    public MyThread(String name, List<Runnable> tasks){
        super(name);
        this.tasks=tasks;
    }
    @Override
    public void run() {
        while (tasks.size() > 0){
            Runnable r= tasks.remove(0);
            r.run();
        }
    }
}

public class MyThreadPool {
    private List<Runnable>  tasks = Collections.synchronizedList(new LinkedList<>());
    /**
     * 當(dāng)前線程數(shù)
     */
    private int num;
    /**
     * 核心線程數(shù)
     */
    private int corePoolSize;
    /**
     * 最大線程數(shù)
     */
    private int maxSize;
    /**
     * 任務(wù)隊列數(shù)
     */
    private int workSize;
    public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
        this.corePoolSize = corePoolSize;
        this.maxSize = maxSize;
        this.workSize = workSize;
    }
    /**
     * 提交任務(wù)
     */
    public void submit(Runnable r){
        if (tasks.size()>=workSize && tasks.size() > maxSize){
            System.out.println("任務(wù):"+r+"被丟棄了");
        }else{
            tasks.add(r);
            execTask(r);
        }
    }
    public void execTask(Runnable r){
        if (corePoolSize > num){
            new MyThread("核心線程:"+num,tasks).start();
            num++;
        }else  if(num < maxSize){
            new MyThread("非核心線程:"+num,tasks).start();
            num++;
        }else{
            System.out.println("任務(wù):"+r+"被緩存了");
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        MyThreadPool myThreadPool = new MyThreadPool(2, 4, 20);
        for (int i =0;i< 300;i++){
            MyTask myTask = new MyTask(i);
            myThreadPool.submit(myTask);
        }
    }
}