Java 线程池全面解析

时间  2020-08-06
标签 java 线程 全面 解析 栏目 Java 繁體版
原文   原文链接

Java-五种线程池，四种拒绝策略，三种阻塞队列

  • 三种阻塞队列：

    BlockingQueue<Runnable> workQueue = null;
    workQueue = new ArrayBlockingQueue<>(5);//基于数组的先进先出队列，有界
    workQueue = new LinkedBlockingQueue<>();//基于链表的先进先出队列，无界
    workQueue = new SynchronousQueue<>();//无缓冲的等待队列，无界html

  • 四种拒绝策略：

    RejectedExecutionHandler rejected = null;
    rejected = new ThreadPoolExecutor.AbortPolicy();//默认，队列满了丢任务抛出异常
    rejected = new ThreadPoolExecutor.DiscardPolicy();//队列满了丢任务不异常
    rejected = new ThreadPoolExecutor.DiscardOldestPolicy();//将最先进入队列的任务删，以后再尝试加入队列
    rejected = new ThreadPoolExecutor.CallerRunsPolicy();//若是添加到线程池失败，那么主线程会本身去执行该任务java

  • 五种线程池：

    ExecutorService threadPool = null;
    threadPool = Executors.newCachedThreadPool();//有缓冲的线程池，线程数 JVM 控制
    threadPool = Executors.newFixedThreadPool(3);//固定大小的线程池
    threadPool = Executors.newScheduledThreadPool(2);
    threadPool = Executors.newSingleThreadExecutor();//单线程的线程池，只有一个线程在工做
    threadPool = new ThreadPoolExecutor();//默认线程池，可控制参数比较多数组

1. 什么是线程池？

很简单，简单看名字就知道是装有线程的池子，咱们能够把要执行的多线程交给线程池来处理，和链接池的概念同样，经过维护必定数量的线程池来达到多个线程的复用。安全

2. 线程池的好处

咱们知道不用线程池的话，每一个线程都要经过new Thread(xxRunnable).start()的方式来建立并运行一个线程，线程少的话这不会是问题，而真实环境可能会开启多个线程让系统和程序达到最佳效率，当线程数达到必定数量就会耗尽系统的CPU和内存资源，也会形成GC频繁收集和停顿，由于每次建立和销毁一个线程都是要消耗系统资源的，若是为每一个任务都建立线程这无疑是一个很大的性能瓶颈。因此，线程池中的线程复用极大节省了系统资源，当线程一段时间再也不有任务处理时它也会自动销毁，而不会长驻内存。多线程

3. 线程池核心类-- 参数流程详解

在java.util.concurrent包中咱们能找到线程池的定义，其中ThreadPoolExecutor是咱们线程池核心类，首先看看线程池类的主要参数有哪些。并发

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters and default thread factory.
 */
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
}
  • corePoolSize：线程池的核心大小，也能够理解为最小的线程池大小。
  • maximumPoolSize：最大线程池大小。
  • keepAliveTime：空余线程存活时间，指的是超过corePoolSize的空余线程达到多长时间才进行销毁。
  • unit：销毁时间单位。
  • workQueue：存储等待执行线程的工做队列。
  • threadFactory：建立线程的工厂，通常用默认便可。
  • handler：拒绝策略，当工做队列、线程池全已满时如何拒绝新任务，默认抛出异常。

4. 线程池工做流程

  • 一、若是线程池中的线程小于corePoolSize时就会建立新线程直接执行任务。
  • 二、若是线程池中的线程大于corePoolSize时就会暂时把任务存储到工做队列workQueue中等待执行。
  • 三、若是工做队列workQueue也满时，当线程数小于最大线程池数maximumPoolSize时就会建立新线程来处理，而线程数大于等于最大线程池数maximumPoolSize时就会执行拒绝策略。

5. 线程池分类

Executors是jdk里面提供的建立线程池的工厂类，它默认提供了4种经常使用的线程池应用，而没必要咱们去重复构造。async

  • newFixedThreadPool
    固定线程池，核心线程数和最大线程数固定相等，而空闲存活时间为0毫秒，说明此参数也无心义，工做队列为最大为Integer.MAX_VALUE大小的阻塞队列。当执行任务时，若是线程都很忙，就会丢到工做队列等有空闲线程时再执行，队列满就执行默认的拒绝策略。
/**
  * Creates a thread pool that reuses a fixed number of threads
  * operating off a shared unbounded queue, using the provided
  * ThreadFactory to create new threads when needed. 
  */
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
}
  • newCachedThreadPool
    带缓冲线程池，从构造看核心线程数为0，最大线程数为Integer最大值大小，超过0个的空闲线程在60秒后销毁，SynchronousQueue这是一个直接提交的队列，意味着每一个新任务都会有线程来执行，若是线程池有可用线程则执行任务，没有的话就建立一个来执行，线程池中的线程数不肯定，通常建议执行速度较快较小的线程，否则这个最大线程池边界过大容易形成内存溢出。
/**
  * Creates a thread pool that creates new threads as needed, but
  * will reuse previously constructed threads when they are
  * available.  These pools will typically improve the performance
  * of programs that execute many short-lived asynchronous tasks.
  */
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}
  • newSingleThreadExecutor
    单线程线程池，核心线程数和最大线程数均为1，空闲线程存活0毫秒一样无心思，意味着每次只执行一个线程，多余的先存储到工做队列，一个一个执行，保证了线程的顺序执行。
/**
 * Creates an Executor that uses a single worker thread operating
 * off an unbounded queue. (Note however that if this single
 * thread terminates due to a failure during execution prior to
 * shutdown, a new one will take its place if needed to execute
 * subsequent tasks.)  Tasks are guaranteed to execute
 * sequentially, and no more than one task will be active at any
 * given time. Unlike the otherwise equivalent
 */
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
  • newScheduledThreadPool
    调度线程池，即按必定的周期执行任务，即定时任务，对ThreadPoolExecutor进行了包装而已。
/**
 * Creates a thread pool that can schedule commands to run after a
 * given delay, or to execute periodically.
 */
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

6. 拒绝策略

  • AbortPolicy
    简单粗暴，直接抛出拒绝异常，这也是默认的拒绝策略。
  • CallerRunsPolicy
    若是线程池未关闭，则会在调用者线程中直接执行新任务，这会致使主线程提交线程性能变慢。
  • DiscardPolicy
    从方法看没作任务操做，即表示不处理新任务，即丢弃。
  • DiscardOldestPolicy
    抛弃最老的任务，就是从队列取出最老的任务而后放入新的任务进行执行。

7.缓冲队列BlockingQueue

  1. 缓冲队列BlockingQueue简介：ide

    BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，容许两个线程同时向队列一个存储，一个取出操做。在保证并发安全的同时，提升了队列的存取效率。
  2. 经常使用的几种BlockingQueue：
  • ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。
  • LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。
  • PriorityBlockingQueue（）或者（int i）:相似于LinkedBlockingQueue，可是其所含对象的排序不是FIFO，而是依据对象的天然顺序或者构造函数的Comparator决定。
  • SynchronizedQueue（）:特殊的BlockingQueue，对其的操做必须是放和取交替完成。

8. 如何提交线程

能够先随便定义一个固定大小的线程池函数

ExecutorService es = Executors.newFixedThreadPool(3);

提交一个线程性能

es.submit(xxRunnble);
es.execute(xxRunnble);

submit和execute分别有什么区别呢？

    1. execute没有返回值，若是不须要知道线程的结果就使用execute方法，性能会好不少。
    1. submit返回一个Future对象，若是想知道线程结果就使用submit提交，并且它能在主线程中经过Future的get方法捕获线程中的异常。

咱们来看看execute()到底方法是如何处理的：

    1. 获取当前线程池的状态。
    1. 当前线程数量小于coreSize时建立一个新的线程运行。
    1. 若是当前线程处于运行状态，而且写入阻塞队列成功。
    1. 双重检查，再次获取线程状态；若是线程状态变了（非运行状态）就须要从阻塞队列移除任务，并尝试判断线程是否所有执行完毕，同时执行拒绝策略。
    1. 若是当前线程池为空就新建立一个线程并执行。
    1. 若是在第三步的判断为非运行状态，尝试新建线程，若是失败则执行拒绝策略。

9. 如何关闭线程池

es.shutdown();

再也不接受新的任务，以前提交的任务等执行结束再关闭线程池。

es.shutdownNow();

再也不接受新的任务，试图中止池中的任务再关闭线程池，返回全部未处理的线程list列表。

10. 总结

线程池主要用来解决线程生命周期开销问题和资源不足问题。经过对多个任务重复使用线程，线程建立的开销就被分摊到多个任务上，并且因为在请求到达时线程已经存在，因此消除线程建立所带来的延迟。这样，就能够当即为请求服务，使应用程序响应更快。另外，经过适当的调整线程中的线程数目能够防止出现资源不足。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程