最详尽的线程池整理

最详尽的线程池整理

本文将从线程池创建、线程池各参数、以及线程池异常处理等各方面详解线程池使用。

一.线程池的优点

线程池主要存在以下优点：

1.降低系统资源消耗，通过重用已存在线程，降低线程创建和销毁造成的损耗。

2.提高响应速度，可通过复用已存在的线程，无需等待新线程创建便立即执行

3.方便线程并发数管控，因为线程无限制创建，可能会导致内存占用过多而产生OOM(内存溢出)

4.可提供延时定时线程池

二.线程池的创建

接下来讲解的就是线程池的重点了，线程池创建有两种方法。一个是通过ThreadPoolExector类,一个是通过Executors。

直接通过ThreadPoolExecutor创建

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,     BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

各个参数所代表的意义，应该网上也有很多：

1、corePoolSize（线程池基本大小）：当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，（除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。）

2、maximumPoolSize（线程池最大大小）：线程池所允许的最大线程个数。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。

3、keepAliveTime（线程存活保持时间）当线程池中线程数大于核心线程数时，线程的空闲时间如果超过线程存活时间，那么这个线程就会被销毁，直到线程池中的线程数小于等于核心线程数。

4、workQueue（任务队列）：用于传输和保存等待执行任务的阻塞队列。

5、threadFactory（线程工厂）：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号）。

5、handler（线程饱和策略）：当线程池和队列都满了，再加入线程会执行此策略。（饱和策略有哪些后面会讲）

各个参数在线程池流程中所起到的作用，我们简单用一个图来介绍下

 

当有线程过来时，判断核心线程数是否已满，没满创建一个新的工作线程来执行任务

如果核心线程数已满，那么就看工作队列，队列未满就放到队列等待（FIFO）,

队列已满就看当前线程数是否少于最大线程数，小于就创建新线程

大于的话就执行饱和策略

 

通过Executors类创建的话，可选择4种不同的线程池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor（其实质都是ThreadPoolExecutor，好比是出厂就设置好了的ThreadPoolExecutor）。

截取一段源码大家看了就知道了

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

那么这四种线程池分别有什么作用呢？

1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

4、newScheduledThreadPool：适用于执行延时或者周期性任务。

 

三.线程池的任务提交execute 和submit

1.execute提交的是Runnable类型的任务，而submit提交的是Callable或者Runnable类型的任务

2.execute的提交没有返回值，而submit的提交会返回一个Future类型的对象

3.execute提交的时候，如果有异常，就会直接抛出异常，而submit在遇到异常的时候，通常不会立马抛出异常，而是会将异常暂时存储起来，等待你调用Future.get()方法的时候，才会抛出异常

execute 方法是在 Executor 接口中定义的，源码如下：

public interface Executor {
    void execute(Runnable command);
}

其中ThreadPoolExecutor继承了AbstractExecutorService抽象类，而AbstractExecutorService 实现了ExecutorService接口，ExecutorService又继承了Executor, submit方法是在ExecutorService 中定义的，AbstractExecutorService 实现的

   public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }
​

可以看到submit其实最终还是调了一个execute,而且他将返回结果放在了一个future中（newTaskFor 就是用来返回一个FutureTask的），其最后执行的是FutureTask.run方法，我们重点看下这个方法：

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                //如有异常就保存在ex中
                setException(ex);
            }
            if (ran)  //如果运行成功就会返回值
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

那么就是说你其实如果有异常，就保存在自己的局部变量中，在外部是看不到异常的堆栈的，那么我们线程池中要怎么捕获异常呢（这个后面会讲到），我们要拿返回值的话，可以通过Future.get()方法，不过这个方法是有可能造成堵塞的，我们可根据 Future.isDone()方法判断是否完成了，再去拿返回值

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        //未完成造成阻塞等待
        s = awaitDone(false, 0L);
    return report(s);
}

综上，我们可以看到当不期望返回结果的时候，使用execute还是可以提升性能的

四.线程池的饱和策略

当一个有限队列充满后，线程池的饱和策略开始起作用。ThreadPoolExecutor的饱和策略可通过调用setRejectedExecutionHandler来修改。不同的饱和策略如下：

1.AbortPolicy(默认):中止,executor抛出未检查RejectedExecutionException，调用者捕获这个异常，然后自己编写能满足自己需求的处理代码。

2.DiscardRunsPolicy:遗弃最旧的，选择丢弃的任务，是本应接下来就执行的任务。

3.DiscardPolicy:遗弃会默认放弃最新提交的任务（这个任务不能进入队列等待执行时）

4.CallerRunsPolicy：调用者运行，既不会丢弃哪个任务，也不会抛出任何异常，把一些任务推回到调用者那里，以此减缓新任务流。它不会在池线程中执行最新提交的任务，但它会在一个调用了execute的线程中执行。

五.线程池捕捉异常

如果线程在运行过程出现RuntimeException 怎么去捕捉呢

可能大家一开始就会想这样做（我一开始也是这样想的）

        try {
            ExecutorService exec = Executors.newCachedThreadPool();
            exec.execute(new ExceptionThread());
            
        } catch (RuntimeException e) {
            System.out.println("捕获异常");
        }
​

但是这样是捕捉不到的， 在java多线程程序中，所有线程都不允许抛出未捕获的checked exception（比如sleep时的InterruptedException），也就是说各个线程需要自己把自己的checked exception处理掉。线程是独立执行的代码片断，线程的问题应该由线程自己来解决，而不要委托到外部。

在Java中，线程方法的异常（无论是checked还是unchecked exception），都应该在线程代码边界之内（run方法内）进行try catch并处理掉.换句话说，我们不能捕获从线程中逃逸的异常。

Java SE5之后，我们可以通过Executor来解决这个我问题。为了解决这个问题，我们需要修改Executor产生线程的方式。Thread.UncaughtExceptionHandler是java SE5中的新接口，它允许我们在每一个Thread对象上添加一个异常处理器。（UncaughtExceptionHandler）。

1.创建异常捕获类

 

public class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("线程名字===="+t.getName());
        System.out.println("捕获异常" + e.toString());
        }
 }

2.创建一个ThreadFactory

​
public class HandlerThreadFactory implements ThreadFactory {
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    //线程名字前缀
    private final String namePrefix;
 
    public HandlerThreadFactory(String namePrefix) {
        this.namePrefix = namePrefix+"-";
    }
 
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread( r,namePrefix + threadNumber.getAndIncrement());
        System.out.println("创建一个新的线程");
        t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
        System.out.println("eh121 = " + t.getUncaughtExceptionHandler());
        return t;
    }
 
}

3.创建运行类ExceptionThread

public class ExceptionThread implements Runnable {
    @Override
    public void run() {
        System.out.println("准备抛出异常");
        throw new RuntimeException();
    }
    public static void main(String[] args) {
        //创建线程
        Thread thread = new Thread(new ExceptionThread());
        //创建线程池 指定线程池创建线程的 ThreadFactory 并设置线程名字
        ExecutorService service = Executors.newCachedThreadPool(new HandlerThreadFactory("专属线程名字"));
        service.execute(thread);
    }
 
}

 

也就是说 我们可以通过Thread.setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler )为每个线程添加一个异常处理器。如果使用excute 方法，没有实现一个handler的话，就会使用默认的handler，submit异常会绑定到future上，可通过future.get方法拿到异常信息 。