手动实现一个简单线程池

1.创建一个线程类

import java.util.concurrent.ArrayBlockingQueue;

public class MyThread extends Thread {

    private Runnable task;
    private ArrayBlockingQueue<Runnable> taskQueue; //线程池队列

    //构造方法传入参数
    public MyThread(Runnable task, ArrayBlockingQueue<Runnable> taskQueue) {
        this.task = task;
        this.taskQueue = taskQueue;
    }

    @Override
    public void run() {
        while (true){
            if(task != null){
                task.run();
                task = null;
            }else {
                Runnable runnable = taskQueue.poll();
                if(runnable != null){
                    runnable.run();
                }
            }
        }
    }
}

2. 创建一个线程池

import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;

public class MyThreadPool {

    private ArrayList<Thread> threads;  //线程池
    private ArrayBlockingQueue<Runnable> taskQueue; //线程池队列
    private int threadNum; //线程池初始化线程数
    private int workThreadNum;  //工作中的线程数



    public MyThreadPool(int initPoolNum) {
        threadNum = initPoolNum;
        threads = new ArrayList<>(initPoolNum);
//任务队列初始化为线程池线程数的四倍
        taskQueue = new ArrayBlockingQueue<>(initPoolNum * 4);

        threadNum = initPoolNum;
        workThreadNum = 0;
    }

    public synchronized void execute(Runnable runnable) {

//线程池未满，每加入一个任务则开启一个线程
        if (workThreadNum < threadNum) {
            MyThread myThead = new MyThread(runnable,taskQueue);
            myThead.start();
            threads.add(myThead);
            workThreadNum++;
        }
//线程池已满，放入任务队列，等待有空闲线程时执行
        else {
//队列已满，无法添加时，拒绝任务
            if (!taskQueue.offer(runnable)) {
                //rejectTask();
                System.out.println("线程池已满");
            }
        }
    }

    public ArrayList<Thread> getThreads() {
        return threads;
    }

    public void setThreads(ArrayList<Thread> threads) {
        this.threads = threads;
    }

    public ArrayBlockingQueue<Runnable> getTaskQueue() {
        return taskQueue;
    }

    public void setTaskQueue(ArrayBlockingQueue<Runnable> taskQueue) {
        this.taskQueue = taskQueue;
    }

    public int getThreadNum() {
        return threadNum;
    }

    public void setThreadNum(int threadNum) {
        this.threadNum = threadNum;
    }

    public int getWorkThreadNum() {
        return workThreadNum;
    }

    public void setWorkThreadNum(int workThreadNum) {
        this.workThreadNum = workThreadNum;
    }
}

3. 测试

public class Test {

    public static void main(String[] args) {
        MyThreadPool myThreadPool = new MyThreadPool(5);
        for (int i = 0; i < 20; i++) {
            myThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "执行中");
                }
            });
            System.out.println("线程池线程数量====》" + myThreadPool.getThreads().size());
            System.out.println("线程池等待队列数量=》" + myThreadPool.getTaskQueue().size());
        }

    }
}

结果如下：