自定义手写简单线程池

一、编写任务类（MyTask）

/**
 * @author yun
 * @description 任务类
 * @date 2020-07-13 18:38
 */
public class MyTask implements Runnable {
    private int id;

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

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

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

二、编写线程类

/**
 * @author yun
 * @description 线程类
 * @date 2020-07-13 18:58
 */
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();
        }
    }
}

三、编写线程池

/**
 * 这是自定义的线程池类
 * 成员变量：
 *      1、任务队列 集合 需要控制线程安全问题
 *      2、当前线程数量
 *      3、核心线程数量
 *      4、最大线程数量
 *      5、任务队列的长度
 * 成员方法：
 *      7、提交任务：
 *          将任务添加到集合中，需要判断是否超出了任务总长度
*       8、执行任务
 *          判断当前线程的数量，决定创建核心线程还是非核心线程
 */
public class MyThreadPool {
    //1、任务队列 集合 需要控制线程安全问题
    List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());
    //2、当前线程数量
    private int num;
    //3、核心线程数量
    private int corePoolSize;
    //4、最大线程数量
    private int maxPoolSize;
    //5、任务队列的长度
    private int workSize;

    public MyThreadPool(int corePoolSize, int maxPoolSize, int workSize) {
        this.corePoolSize = corePoolSize;
        this.maxPoolSize = maxPoolSize;
        this.workSize = workSize;
    }
    //7、提交任务：
    //      将任务添加到集合中，需要判断是否超出了任务总长度
    public void submit(Runnable r){
        if(tasks.size() >= workSize){
            System.out.println("任务："+r+" 被抛弃了");
        }else {
            tasks.add(r);
            //8、执行任务 判断当前线程的数量，决定创建核心线程还是非核心线程
            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+"被缓存了");
        }
    }
}

四、测试类

/**
 * 1、创建线程池对象
 * 2、提交多个任务
 */
public class MyTest {
    public static void main(String[] args) {
        //1、创建线程池对象
        MyThreadPool threadPool = new MyThreadPool(2, 4, 20);
        for (int i = 0; i < 10; i++) {
            //2、提交多个任务
            MyTask task = new MyTask(i);
            threadPool.submit(task);
        }
    }
}