一、什么是线程池：

线程池就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后再创建线程后自动启动这些任务。

不废话，直接代码

1、编写任务类，实现Runnable接口

2、编写线程类，用于执行任务，需要持有所有任务

3、编写线程池类，包含提交任务，执行任务的能力

4、编写测试类，创建线程池对象，提交多个任务测试

任务类

/*
 * @Author 吕习伟
 * @Date 22:25 2020/8/18
 * @Param
 * @return
 * @Description 任务类 任务编号，任务执行时间
 **/
public class MyTask implements Runnable{
    private int task_id;

    public MyTask(int task_id) {
        this.task_id = task_id;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println("线程："+name+"即将执行任务："+task_id);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程："+name+"完成任务："+task_id);
    }


    @Override
    public String toString() {
        return "MyTask{" +
                "task_id=" + task_id +
                '}';
    }
}

线程类

import java.util.List;

/*
 * @Author 吕习伟
 * @Date 22:30 2020/8/18
 * @Param
 * @return
 * @Description 编写一个线程类
 **/
public class MyWork extends Thread{
    private String name;
    private List<Runnable> tasks;

    public MyWork(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();
        }

    }
}

线程池类

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class MyThreadPool {
    //任务队列，集合形式，需要控制线程全局安全问题
    private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());
    //当前线程数量
    private int num;
    //核心线程数量
    private int corePoolSize;
    //最大线程数量
    private int maxPoolSize;
    //任务队列的长度
    private int workSize;

    public MyThreadPool(int corePoolSize, int maxPoolSize, int workSize) {
        this.corePoolSize = corePoolSize;
        this.maxPoolSize = maxPoolSize;
        this.workSize = workSize;
    }

    //提交任务方法
    public void submit(Runnable r){
        //判断任务的数量是否超出了做大任务数量
        if (tasks.size() >= workSize){
            System.out.println("队列已经满了，任务："+r+"被丢弃了。。。。");

        }else {

            tasks.add(r);
            //执行任务
            execTask(r);
        }
    }
    //  执行任务
    private void execTask(Runnable r) {
        //判断线程池中的线程总数量，是否超出核心线程数，
        if (num < corePoolSize){
            new MyWork("核心线程:"+num,tasks).start();
            num++;
        }else if (num <maxPoolSize){
            new MyWork("非核心线程:"+num,tasks).start();
            num++;
        }else {
            System.out.println("任务:"+r+"被缓存了。。。。");
        }
    }
}

测试

public class MyTest {
    public static void main(String[] args) {
        MyThreadPool pool = new MyThreadPool(2,4,20);
        for (int i = 0; i <100; i++) {
            MyTask task = new MyTask(i);
            pool.submit(task);
        }
    }
}