多线程之(线程管理)

线程管理

线程池技术

什么是线程池

1. 可以以 new Thread( () -> { 线程执行的任务 }).start(); 这种形式开启一个线程. 当 run()方法运行结束,线程对象会被 GC 释放.
2. 在真实的生产环境中,可能需要很多线程来支撑整个应用,当线程数量非常多时 ,反而会耗尽 CPU 资源. 如果不对线程进行控制与管理,反而会影响程序的性能.
3. 线程开销主要包括: 创建与启动线程的开销;线程销毁开销; 线程调度的开销; 线程数量受限 CPU 处理器数量.
4. 线程池就是有效使用线程的一种常用方式. 线程池内部可以预先创建一定数量的工作线程,客户端代码直接将任务作为一个对象提交给线程池, 线程池将这些任务缓存在工作队列中,线程池中的工作线程不断地从队列中取出任务并执行. 

线程池的工作流程

JDK对线程池的支持

Executor的UML图

关键类说明

Executor接口:

void	execute(Runnable command) 在将来的某个时间执行给定的命令。

ExecutorService接口

boolean	awaitTermination(long timeout, TimeUnit unit) 阻止所有任务在关闭请求完成后执行，或发生超时，或当前线程中断，以先到者为准。
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks) 执行给定的任务，返回持有他们的状态和结果的所有完成的期货列表。
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) 执行给定的任务，返回在所有完成或超时到期时持有其状态和结果的期货列表，以先发生者为准。
<T> T	invokeAny(Collection<? extends Callable<T>> tasks) 执行给定的任务，返回一个成功完成的结果（即没有抛出异常），如果有的话。
<T> T	invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) 执行给定的任务，返回一个已经成功完成的结果（即，不抛出异常），如果有的话在给定的超时之前过去。
boolean	isShutdown() 如果此执行者已关闭，则返回 true 。
boolean	isTerminated() 如果所有任务在关闭后完成，则返回 true 。
void	shutdown() 启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
List<Runnable>	shutdownNow() 尝试停止所有主动执行的任务，停止等待任务的处理，并返回正在等待执行的任务列表。
<T> Future<T>	submit(Callable<T> task) 提交值返回任务以执行，并返回代表任务待处理结果的Future。
Future<?>	submit(Runnable task) 提交一个可运行的任务执行，并返回一个表示该任务的未来。
<T> Future<T>	submit(Runnable task, T result) 提交一个可运行的任务执行，并返回一个表示该任务的未来。

ScheduledExecutorService接口

 

<V> ScheduledFuture<V>	schedule(Callable<V> callable, long delay, TimeUnit unit) 创建并执行在给定延迟后启用的ScheduledFuture。
ScheduledFuture<?>	schedule(Runnable command, long delay, TimeUnit unit) 创建并执行在给定延迟后启用的单次操作。
ScheduledFuture<?>	scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 创建并执行在给定的初始延迟之后，随后以给定的时间段首先启用的周期性动作; 那就是执行将在initialDelay之后开始，然后是initialDelay+period ，然后是initialDelay + 2 * period ，等等。
ScheduledFuture<?>	scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 创建并执行在给定的初始延迟之后首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟。

 简单的实例:

package com.edu.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 线程池的基本使用
 */
public class Test01 {
    public static void main(String[] args) {
        //创建有 5 个线程大小的线程池,(创建一个可重用不受限制的队列操作线程的固定数目的线程池。)
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        //向线程池中提交 18 个任务,这 18 个任务存储到线程池的阻塞队列中, 线程池中这5 个线程就从阻塞队列中取任务执行
        for (int i = 0; i < 18; i++) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getId() + " 编号的任务在执行任务, 开始时间:" + System.currentTimeMillis());
                    try {
                        Thread.sleep(3000); //模拟任务执行时长
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

package com.edu.threadpool;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 线程池的计划任务
 * <ul>
 *      <li>static ThreadFactory defaultThreadFactory()
 *      返回用于创建新线程的默认线程工厂。</li>
 *      <li>static ExecutorService newCachedThreadPool()
 *      创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。</li>
 *      <li>static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
 *      创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程，并在需要时使用提供的ThreadFactory创建新线程。</li>
 *      <li>static ExecutorService newFixedThreadPool(int nThreads)
 *      创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。</li>
 *      <li>static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
 *      创建一个线程池，重用固定数量的线程，从共享无界队列中运行，使用提供的ThreadFactory在需要时创建新线程。</li>
 *      <li>static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 *      创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。</li>
 *      <li>static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
 *      创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。  </li>
 * </ul>
 */
public class Test02 {
    public static void main(String[] args) {
        //创建一个有调度功能的线程池(创建一个线程池，它可安排命令给定延迟后运行或定期执行。)
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(10);
        //在延迟 2 秒后执行任务, schedule( Runnable 任务, 延迟时长, 时间单位)
//        scheduledExecutorService.schedule(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getId() + " -- " +
//                        System.currentTimeMillis());
//            }
//
//        }, 2, TimeUnit.SECONDS);


        //以固定的频率执行任务,开启任务的时间是固定的, 在 3 秒后执行任务,以后每隔 5 秒重新执行一次
//        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getId() + "----在固定频率开启任务---" + System.currentTimeMillis());
//                try {
//                    TimeUnit.SECONDS.sleep(1); //睡眠模拟任务执行时间 ,如果任务执行时长超过了时间间隔, 则任务完成后立即开启下个任务
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//        }, 3, 2, TimeUnit.SECONDS);


        //在上次任务结束后,在固定延迟后再次执行该任务,不管执行任务耗时多长,总是在任务结束后的 2 秒再次开启新的任务
        scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + "----在固定频率开启任务-- - " + System.currentTimeMillis());
                try {
                    TimeUnit.SECONDS.sleep(1); //睡眠模拟任务执行时间 ,如果任务执行时长超过了时间间隔, 则任务完成后立即开启下个任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2, TimeUnit.SECONDS);

        //关闭线程池
//        scheduledExecutorService.shutdown();
    }
}

Executors的底层实现(只看线程池相关的)

public static ExecutorService newCachedThreadPool() {
　　return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
　　60L, TimeUnit.SECONDS,
　　new SynchronousQueue<Runnable>());
}

该线程池在极端情况下,每次提交新的任务都会创建新的线程执行. 适合用来执行大量
耗时短并且提交频繁的任务

public static ExecutorService newFixedThreadPool(int nThreads) {
　　return new ThreadPoolExecutor(nThreads, nThreads,
　　0L, TimeUnit.MILLISECONDS,
　　new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newSingleThreadExecutor() {
　　return new FinalizableDelegatedExecutorService
　　(new ThreadPoolExecutor(1, 1,
　　0L, TimeUnit.MILLISECONDS,
　　new LinkedBlockingQueue<Runnable>()));
}

总结:

Excutors 工 具 类 中 返 回 线 程 池 的 方 法 底 层 都 使 用 了ThreadPoolExecutor 线程池,这些方法都是 ThreadPoolExecutor 线程池的封装

分析ThreadPoolExecutor

构造器源码

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
RejectedExecutionHandler handler) 

参数名	含义
corePoolSize	指定线程池中核心线程的数量
maxinumPoolSize	指定线程池中最大线程数量
keepAliveTime	当线程池线程的数量超过 corePoolSize 时,多余的空 闲线程的存活时长,即空闲线程在多长时长内销毁
unit	是 keepAliveTime 时长单位
workQueue	任务队列,把任务提交到该任务队列中等待执行
threadFactory	线程工厂,用于创建线程
handler	拒绝策略,当任务太多来不及处理时,如何拒绝

 

workQueue任务队列说明

workQueue 工 作 队 列 是 指 提 交 未 执 行 的 任 务 队 列 , 它 是BlockingQueue 接口的对象,仅用于存储 Runnable 任务.根据队列功能分类,在 ThreadPoolExecutor 构造方法中可以使用以下几种阻塞
队列:

直接提交队列	由 SynchronousQueue 对象提供,该队列没有 容量,提交给线程池的任务不会被真实的保存,总是将新的任务提 交给线程执行,如果没有空闲线程,则尝试创建新的线程,如果线程 数量已经达到 maxinumPoolSize 规定的最大值则执行拒绝策略
有界任务队列	由 ArrayBlockingQueue 实 现 , 在 创 建 ArrayBlockingQueue 对象时,可以指定一个容量. 当有任务需要执 行时,如果线程池中线程数小于 corePoolSize 核心线程数则创建新 的线程;如果大于 corePoolSize 核心线程数则加入等待队列.如果队 列已满则无法加入,在线程数小于 maxinumPoolSize 指定的最大线 程 数 前 提 下 会 创 建 新 的 线 程 来 执 行 , 如 果 线 程 数 大 于 maxinumPoolSize 最大线程数则执行拒绝策略
无界任务队列	由 LinkedBlockingQueue 对象实现,与有界队 列相比,除非系统资源耗尽,否则无界队列不存在任务入队失败的 情况. 当有新的任务时,在系统线程数小于 corePoolSize 核心线程 数则创建新的线程来执行任务;当线程池中线程数量大于 corePoolSize 核心线程数则把任务加入阻塞队列
优先任务队列	通过 PriorityBlockingQueue 实现的,是带有 任 务 优 先 级 的 队 列 , 是 一 个 特 殊 的 无 界 队 列 . 不 管 是 ArrayBlockingQueue 队列还是 LinkedBlockingQueue 队列都是按照 先进先出算法处理任务的.在 PriorityBlockingQueue 队列中可以根 据任务优先级顺序先后执行.

 

有界任务队列执行任务逻辑说明

拒绝策略(handle)

ThreadPoolExecutor 构造方法的最后一个参数指定了拒绝策略.当提交给线程池的任务量超过实际承载能力时,如何处理? 即线程池中的线程已经用完了,等待队列也满了,无法为新提交的任务服务,可以通过拒绝策略来处理这个问题. JDK 提供了四种拒绝策略:

1. AbortPolicy 策略,会抛出异常CallerRunsPolicy 策略,只要线程池没关闭,会在调用者线程中运行当前被丢弃的任务[Executors 工具类提供的静态方法返回的线程池默认的拒绝策略是AbortPolicy 抛出异常]
2. DiscardOldestPolicy 将任务队列中最老的任务丢弃,尝试再次提交新任务
3. DiscardPolicy 直接丢弃这个无法处理的任务
4. RejectedExecutionHandler  如果内置的拒绝策略无法满足实际需求,可以扩展 RejectedExecutionHandler 接口 

RejectedExecutionHandler接口的简单实例

package com.edu.threadpool;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 自定义拒绝策略
 */
public class Test03 {
    public static void main(String[] args) {
        //定义任务
        Runnable r = new Runnable() {
            @Override
            public void run() {
                int num = new Random().nextInt(5);
                System.out.println(Thread.currentThread().getId() + "--" +
                        System.currentTimeMillis() + "开始睡眠" + num + "秒");
                try {
                    TimeUnit.SECONDS.sleep(num);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //创建线程池, 自定义拒绝策略
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(), new
                RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        //r 就是请求的任务, executor 就是当前线程池
                        System.err.println(r + " is discarding..");
                        System.exit(1);
                    }
                });
        //向线程池提交若干任务
        for (int i = 0; i < 20; i++) {
            threadPoolExecutor.submit(r);
        }
    }
}

ThreadFactory 

线程池中的线程就是ThreadFactory来创建的，

ThreadFactory 是一个接口,只有一个用来创建线程的方法:Thread newThread(Runnable r);
当线程池中需要创建线程时就会调用该方法

自定义ThreadFactory实例

package com.edu.threadpool;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 自定义线程工厂
 */
public class Test04 {
    public static void main(String[] args) throws InterruptedException {
        //定义任务
        Runnable r = new Runnable() {
            @Override
            public void run() {
                int num = new Random().nextInt(10);
                System.out.println(Thread.currentThread().getId() + "--"
                        + System.currentTimeMillis() + "开始睡眠:" + num + "秒");
                try {
                    TimeUnit.SECONDS.sleep(num);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        //创建线程池, 使用自定义线程工厂, 采用默认的拒绝策略是抛出异常
        ExecutorService executorService = new ThreadPoolExecutor(
                5,
                5,
                0,
                TimeUnit.SECONDS,
                new SynchronousQueue<>(), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                //根据参数r接收的任务,创建一个线程
                Thread t = new Thread(r);
                t.setDaemon(true);  //设置为守护线程, 当主线程运行结束,线程池中的线程会自动退出
                System.out.println("创建了线程: " + t);
                return t;
            }
        });

        //提交5个任务, 当给当前线程池提交的任务超过5个时,线程池默认抛出异常
        for (int i = 0; i < 5; i++) {
            executorService.submit(r);
        }

        //主线程睡眠
        Thread.sleep(10000);
        //主线程睡眠超时, 主线程结束, 线程池中的线程会自动退出
    }
}

ThreadPoolExecutor  的其他一些基本参数方法(可以用来监控)

int	getActiveCount() 返回正在执行任务的线程的大概数量。
long	getCompletedTaskCount() 返回完成执行的任务的大致总数。
int	getCorePoolSize() 返回核心线程数。
long	getKeepAliveTime(TimeUnit unit) 返回线程保持活动时间，这是超过核心池大小的线程在终止之前可能保持空闲的时间量。
int	getLargestPoolSize() 返回在池中同时进行的最大线程数。
int	getMaximumPoolSize() 返回允许的最大线程数。
int	getPoolSize() 返回池中当前的线程数。
BlockingQueue<Runnable>	getQueue() 返回此执行程序使用的任务队列。
RejectedExecutionHandler	getRejectedExecutionHandler() 返回不可执行任务的当前处理程序。
long	getTaskCount() 返回计划执行的任务的大概总数。
ThreadFactory	getThreadFactory() 返回用于创建新线程的线程工厂。
boolean	isShutdown() 如果此执行者已关闭，则返回 true 。
boolean	isTerminated() 如果所有任务在关闭后完成，则返回 true 。
boolean	isTerminating() 如果此执行者在 shutdown()或 shutdownNow()之后 终止 ，但尚未完全终止，则返回true。

代码实例

package com.edu.threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 监控线程池
 */
public class Test05 {
    public static void main(String[] args) throws InterruptedException {
        //先定义任务
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getId() + " 编号 的线程开始执行: " + System.currentTimeMillis());
                try {
                    Thread.sleep(10000);    //线程睡眠20秒,模拟任务执行时长
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //定义线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 5, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());

        //向线程池提交30个任务
        for (int i = 0; i < 30; i++) {
            poolExecutor.submit(r);
            System.out.println("当前线程池核心线程数量: " + poolExecutor.getCorePoolSize()
                    +", 最大线程数:"+ poolExecutor.getMaximumPoolSize()
                    + ",当前线程池大小:" + poolExecutor.getPoolSize()
                    + ",活动线程数量:" + poolExecutor.getActiveCount()
                    + ",收到任务数量:" + poolExecutor.getTaskCount()
                    + ",完成任务数: " + poolExecutor.getCompletedTaskCount()
                    + ",等待任务数:" + poolExecutor.getQueue().size()) ;
            TimeUnit.MILLISECONDS.sleep(500);
        }

        System.out.println("-----------------------------------------------");
        while ( poolExecutor.getActiveCount() >= 0 ){
            System.out.println("当前线程池核心线程数量: " + poolExecutor.getCorePoolSize() + ", 最大线程数:" + poolExecutor.getMaximumPoolSize() + ",当前线程池大小:" + poolExecutor.getPoolSize() + ",活动线程数量:" + poolExecutor.getActiveCount()+ ",收到任务数量:" + poolExecutor.getTaskCount() + ",完成任务数: " + poolExecutor.getCompletedTaskCount() + ",等待任务数:" + poolExecutor.getQueue().size()) ;
            Thread.sleep(1000);
        }
    }

}

对线程池进行拓展

线程池部分源码

final void runWorker(Worker w) {
//此处省略
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
//此处省略
    }

简单代码实例(看第二个)

//以匿名内部类的形式来继承
//        new Object(){
//            @Override
//            public String toString() {
//                return super.toString();
//            }
//        };

package com.edu.threadpool;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 扩展线程池
 */
public class Test06 {
    //定义任务类
    private static class  MyTask implements  Runnable{
         String name;

        public MyTask(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println(name + "任务正在被线程 " + Thread.currentThread().getId() + " 执行");
            try {
                Thread.sleep(1000);     //模拟任务执行时长
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
//以匿名内部类的形式来继承
//        new Object(){
//            @Override
//            public String toString() {
//                return super.toString();
//            }
//        };
        //定义扩展线程池, 可以定义线程池类继承ThreadPoolExecutor,在子类中重写beforeExecute()/afterExecute()方法
        //也可以直接使用ThreadPoolExecutor的内部类
        ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>() ){
            //在内部类中重写任务开始方法
            @Override
            protected void beforeExecute(Thread t, Runnable r) {
                System.out.println(t.getId() + "线程准备执行任务: " + ((MyTask)r).name);
            }

            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println( ((MyTask)r).name + "任务执行完毕");
            }

            @Override
            protected void terminated() {
                System.out.println("线程池退出");
            }
        };

        //向线程池中添加任务
        for (int i = 0; i < 5; i++) {
            MyTask task = new MyTask("task-" + i);
            executorService.execute(task);
        }

        //关闭线程池
        executorService.shutdown();     //关闭线程池仅仅是说线程池不再接收新的任务 , 线程池中已接收的任务正常执行完毕
    }
}

优化线程大小

程池大小对系统性能是有一定影响的,过大或者过小都会无法发挥最优的系统性能, 线程池大小不需要非常精确,只要避免极大或者极小的情况即可, 一般来说,线程池大小需要考虑 CPU 数量,内存大小等因素.

//基本公式:线程池大小 = CPU 的数量 * 目标 CPU 的使用率*( 1 + 等待时间与计算时间的比)

线程池死锁

如果在线程池中执行的 任务 A 在执行过程中又向线程池提交了任务 B, 任务 B 添加到了线程池的等待队列中, 如果任务 A 的结束需要等待任务 B 的执行结果. 就有可能会出现这种情况: 线程池中所有的工作线程都处于等待任务处理结果,而这些任务在阻塞队列中等待
执行, 线程池中没有可以对阻塞队列中的任务进行处理的线程,这种等待会一直持续下去,从而造成死锁.

总结:因此适合给线程池提交相互独立的任务,而不是彼此依赖的任务. 对于彼此依赖的任务,可以考虑分别提交给不同的线程池来执行

线程池中的异常处理

在使用 ThreadPoolExecutor 进行 submit 提交任务时,有的任务抛出了异常,但是线程池并没有进行提示,即线程池把任务中的异常给吃掉了,

解决方案

1. 把 submit 提交改为 execute 执行
2. 对 ThreadPoolExecutor线程池进行扩展.对提交的任务进行包装:

代码示例:

package com.edu.threadpool;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 演示线程池可能会吃掉程序中的异常
 */
public class Test07 {
    //定义类实现Runnable接口,用于计算两个数相除
    private static class  DivideTask implements  Runnable{
        private  int x;
        private  int y;

        public DivideTask(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "计算:" + x + " / " + y + " = " + (x/y));
        }
    }
    public static void main(String[] args) {
        //创建线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<>());

        //向线程池中添加计算两个数相除的任务
        for (int i = 0; i < 5; i++) {
            poolExecutor.submit(new DivideTask(10, i));
//            poolExecutor.execute(new DivideTask(10, i));
        }
        /*
            运行程序,只有四条计算结果, 我们实际上向线程池提交了5个计算任务,分析结果发现当i==0时,提交的任务会产生算术异常,线程池把该异常给吃掉了,导致我们对该异常一无所知
            解决方法:
                一是把submit()提交方法改为execute();
                二是对线程池进行扩展,对submit()方法进行包装
         */
    }
}

package com.edu.threadpool;

import java.util.concurrent.*;

/**
 * 自定义线程池类,对ThreadPoolExecutor进行扩展
 */
public class Test08 {
    //自定义线程池类
    private static class  TraceThreadPollExecutor extends  ThreadPoolExecutor{
        public TraceThreadPollExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        }
        //定义方法,对执行的任务进行包装,接收两个参数,第一个参数接收要执行的任务,第二个参数是一个Exception异常
        public Runnable wrap( Runnable task, Exception exception){
            return  new Runnable() {
                @Override
                public void run() {
                    try {
                        task.run();
                    }catch (Exception e ){
                        exception.printStackTrace();
                        throw  e;
                    }
                }
            };
        }

        //重写submit方法
        @Override
        public Future<?> submit(Runnable task) {
            return super.submit(wrap(task, new Exception("客户跟踪异常")));
        }

        @Override
        public void execute(Runnable command) {
            super.execute(wrap(command, new Exception("客户跟踪异常")));
        }
    }

    //定义类实现Runnable接口,用于计算两个数相除
    private static class  DivideTask implements  Runnable{
        private  int x;
        private  int y;

        public DivideTask(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "计算:" + x + " / " + y + " = " + (x/y));
        }
    }
    public static void main(String[] args) {
        //创建线程池
//        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<>());
        //使用自定义的线程池
        ThreadPoolExecutor poolExecutor = new TraceThreadPollExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<>());

        //向线程池中添加计算两个数相除的任务
        for (int i = 0; i < 5; i++) {
            poolExecutor.submit(new DivideTask(10, i));
//            poolExecutor.execute(new DivideTask(10, i));
        }

    }
}