【多线程】线程池源码（3）

线程池的源码解读就先告一段落了（其实总感觉缺了什么东西，但是又找不到），本篇文章就简单总结下之前讲的流程及一些用法。

1 线程池流程图

通过两篇文章，可能分开来看每一部分都能看懂，但是总的一个流程没有串联起来，下面看下整体的一个流程图

2 综合例子

接下来再通过一个综合例子对一些知识点进行回顾

2.1 自定义ThreadPoolExecutor

首先自定义ThreadPoolExecutor，然后重写beforeExecute() 和afterExecute() 方法

public class MyThreadPoolExecutor extends ThreadPoolExecutor {
    //省略必须要实现的父类的构造函数，4个

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        System.out.println("【before execution】" + r.toString());
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        System.out.println(r.toString() + "【after execution】");
    }
}

注意，是省略了构造函数，一般IDE都会提示报错， 至少需要实现一个

2.2 自定义RejectedExecutionHandler

自定义拒绝策略，现在没有具体的需求，说好听的是自定义拒绝策略，不好听就是单纯地硬实现而已。

public class MyRejectedExecutionHandler implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("task is rejected");
    }
}

甚至对任务都没做任何处理，知识单纯的控制台输出了一句话。

2.3 监控线程池状态的线程

在一开始也普及过了线程池中相关的一些参数，通过下面这个监视线程能更加直观的了解这些参数

public class MonitorThread implements Runnable {

    private ThreadPoolExecutor executor;


    public MonitorThread(ThreadPoolExecutor executor) {
        this.executor = executor;
    }

    private boolean monitor = true;

    public void stopMonitor() {
        monitor = false;
    }

    @Override
    public void run() {
        while (monitor) {
            System.out.println(
                    String.format("[monitor] [%d/%d] Active: %d, Completed: %d, Task: %d, isShutdown: %s, isTerminated: %s, rejectedExecutionHandler: %s",
                            this.executor.getPoolSize(),
                            this.executor.getCorePoolSize(),
                            this.executor.getActiveCount(),
                            this.executor.getCompletedTaskCount(),
                            this.executor.getTaskCount(),
                            this.executor.isShutdown(),
                            this.executor.isTerminated(),
                            this.executor.getRejectedExecutionHandler()));

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.4 自定义的线程

估计过了这么久了，各位小伙伴也都忘记最初线程初体验开始创建的类了，这里再重复一遍。

public class MyThread implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " processing");
        process();
        System.out.println(Thread.currentThread().getName() + " end");
    }

    private void process() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return String.format("MyThread{%s}", Thread.currentThread().getName());
    }
}

这个虽然是线程，但是在线程池里面其实是看作一个任务，线程池会创建核心线程来执行这个任务（逻辑是这个线程里面的run()方法）。

2.5 测试类

有了以上这些后，就可以开始我们的测试了

public class ThreadPoolInfo {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPoolExecutor executor = new MyThreadPoolExecutor(3,5, 30, TimeUnit.SECONDS, new ArrayBlockingQueue(3), new MyRejectedExecutionHandler());
        MonitorThread monitorThread = new MonitorThread(executor);
        //开启监控线程
        new Thread(monitorThread).start();
        for (int i = 0; i < 10; i++) {
            //开启工作线程
            executor.execute(new MyThread());
        }

        Thread.sleep(12000);
        executor.shutdown();
        Thread.sleep(3000);
        monitorThread.stopMonitor();
    }
}