JUC-并发编程15-手写一个线程池

1、简介

线程池是java并发编程中经常使用的技术，那么自己如何动手写一个线程池呢？

2、属性分析

线程池，首先有要一个池子来放线程，而线程又是用来执行任务的。

• 首先，线程池中的线程应该是有类别的，有的线程是核心线程，有的是非核心线程，所以我们需要对这个两个类别线程数量来标记，就我们常说的coreSize和最大线程数量maxSize。

1. 当线程池中线程数未达到核心线程数coreSize时，来一个任务加一个线程是可以的，也可以提高任务执行的效率。
2. 当线程池中线程数达到核心线程数后，得控制一下线程的数量，来了任务了先进入队列，如果任务执行足够快，这些核心线程很快就能队列中的任务执行完毕，完全没有新增线程的必要。
3. 当任务队列也满了，这时候靠核心线程就无法及时处理任务了，所以这时候就需要新加新的线程了，但是线程也不能无限制的增加，所以需要控制其最大线程数量maxSize。
4. 其次，我们需要一个任务队列来存放任务，这个队列必须是线程安全的，我们一般使用BlockingQueue阻塞队列来充当。
5. 最后，当任务越来越多而线程处理却不及时，迟早会达到了一种状态，队列满了，线程数也达到了最大线程数了。这时候怎么办呢？这时候就需要拒绝策略了。也就是这些无法及时处理的任务怎么办的一种策略，常用的策略有丢弃当前任务，丢弃最老的任务，调用者自己处理，抛出异常等。

根据上面的描述，我们定义一个线程池一共需要这么四个变量：核心线程数coreSize、最大线程数maxSize、阻塞队列BlockingQueue、决策略RejectPolicy。

3、完成代码

public class MyThreadPoolExecutor implements Executor {
    /**
     * 线程池的名称
     */
    private String name;

    /**
     * 核心线程数
     */
    private int coreSize;

    /**
     * 最大线程数
     */
    private int maxSize;

    /**
     * 任务队列
     */
    private BlockingQueue<Runnable> taskQueue;

    /**
     * 决绝策略
     */
    public RejectPolicy rejectPolicy;

    /**
     * 当前正在运行的线程数，需要修改时线程间立即感知，所以使用AtomicInteger
     */
    private AtomicInteger runningCount=new AtomicInteger(0);

    /**
     * 线程序列号
     */
    private AtomicInteger sequence=new AtomicInteger(0);

    public MyThreadPoolExecutor(String name,int coreSize,int maxSize,BlockingQueue<Runnable> taskQueue,RejectPolicy rejectPolicy){
        this.name=name;
        this.coreSize=coreSize;
        this.maxSize=maxSize;
        this.taskQueue=taskQueue;
        this.rejectPolicy=rejectPolicy;
    }

    @Override
    public void execute(Runnable task) {
        //正在运行的线程数
        int count = runningCount.get();
        //如果正在运行的线程数小于核心线程数，直接接一个线程
        if (count<coreSize){
            //这里不一定添加成功，addWorker()方法里面还有判断一次是不是确实小于coreSize
            if (addWorker(task,true)){
                return;
            }
            //如果添加核心线程失败，进入下面的逻辑
        }
        //如果达到了核心线程数，先尝试让任务入队
        //这里之所以使用offer()，是因为如果队列满了offer()会立即返回false
        if (taskQueue.offer(task)){
            //nothing to do,为了逻辑清晰预留
        }else {
            //如果入队失败，说明队列满了，那就添加一个非核心线程
            if (!addWorker(task,false)){
                //如果添加非核心线程失败，那就执行决绝策略
                rejectPolicy.reject(task,this);
            }
        }
    }

    private boolean addWorker(Runnable newTask, boolean core) {
        //自旋判断是不是真的可以创建一个线程
        for (;;){
            //正在运行的线程数
            int count = runningCount.get();
            //核心线程还是非核心线程
            int max=core?coreSize:maxSize;
            //不满足创建线程的条件，直接返回false 如果是核心线程，count>=max 直接进入阻塞队列，如果是非核心线程 count>=max
            //就会进入拒绝策略
            if (count>=max){
                return false;
            }
            //修改runningCount成功，可以创建
            if (runningCount.compareAndSet(count,count+1)){
                //设置线程的名字
                String threadName=(core?"core_":"")+name+sequence.incrementAndGet();
                //创建线程并启动
                new Thread(()->{
                    System.out.println("thread name:"+Thread.currentThread().getName());
                    //设置运行的任务
                    Runnable task=newTask;
                    //不断从任务队列中取任务执行，如果取出来的任务为null，则跳出循环，线程也就结束了。
                    while (task!=null||(task=getTask())!=null){
                        try {
                            //执行任务
                            task.run();
                        }finally {
                            task=null;
                        }
                    }
                },threadName).start();
                break;
            }
        }
        return true;
    }
    private Runnable getTask(){
        try {
            //task()方法会一直阻塞直到取到任务为止
            return taskQueue.take();
        }catch (InterruptedException e){
            //线程中断了，返回null可以结束当前线程
            //当前线程都要结束了，理应要把runningCount的数量减一
            runningCount.decrementAndGet();
            return null;
        }
    }
}

拒绝策略

public interface RejectPolicy {
    void reject(Runnable task,MyThreadPoolExecutor myThreadPoolExecutor);
}

/**
 * 丢弃当前任务实现类
 */
public class DiscardRejectPolicy implements RejectPolicy {
    @Override
    public void reject(Runnable task, MyThreadPoolExecutor myThreadPoolExecutor) {
        //todo
        System.out.println("discard one task:");
    }
}

测试类

public class MyThreadPoolExecutorTest {
    public static void main(String[] args) {
        MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor("test", 5, 10, new ArrayBlockingQueue<>(15), new DiscardRejectPolicy());
        AtomicInteger num = new AtomicInteger(0);
        for (int i = 0; i <100 ; i++) {
            myThreadPoolExecutor.execute(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("running:"+System.currentTimeMillis()+":"+num.incrementAndGet());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

结果如下：

thread name:core_test1
thread name:core_test4
thread name:core_test3
thread name:core_test2
thread name:core_test5
thread name:test6
thread name:test7
thread name:test8
discard one task:
thread name:test9
thread name:test10
...
discard one task:
discard one task:
discard one task:
discard one task:
discard one task:
discard one task:
discard one task:
running:1598512670793:1
running:1598512670794:2
running:1598512670794:10
running:1598512670794:6
running:1598512670794:8
running:1598512670794:9
running:1598512670794:7
running:1598512670794:5
running:1598512670794:3
running:1598512670794:4
running:1598512671793:11
running:1598512671794:12
running:1598512671794:20
running:1598512671794:19
running:1598512671794:18
running:1598512671794:17
running:1598512671794:16
running:1598512671794:15
running:1598512671794:14
running:1598512671794:13
running:1598512672793:21
running:1598512672794:22
running:1598512672794:23
running:1598512672794:24
running:1598512672794:25

分析：

1. 先连续创建了5个核心线程，并执行新任务
2. 后面15个任务进入阻塞队列
3. 队列满了，有连续创建了5个线程，并执行了新任务
4. 后面的没有任务就没得执行了，全部走了丢弃策略
5. 所以真正执行成功的任务就是5+15+5=25个

我们看到就是执行了一个25个任务。