投稿
  1. 极客之音首页
  2. 后端漫谈

Java 线程池详解(上)

飞熊 • • 后端漫谈 • 阅读 183

梦想不抛弃苦心追求的人，只要不停止追求，你们会沐浴在梦想的光辉之中。再美好的梦想与目标，再完美的计划和方案，如果不能尽快在行动中落实，最终只能是纸上谈兵，空想一番。只要瞄准了大方向，坚持不懈地做下去，才能够扫除挡在梦想前面的障碍，实现美好的人生蓝图。Java 线程池详解(上)，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

前面的文章详细的介绍线程相关的内容，但在平时的开发工作中，我们很少去直接创建一个线程使用，一般都是通过线程池的方式来进行调用。这边文章就来介绍一下Java中的线程池是怎么工作的，以及各种线程池之间有什么区别

一、线程与线程池

我们可以通过执行一段相同的代码，来看一下线程和线程池之间的区别

创建多个线程：

Long start = System.currentTimeMillis();
final Random random = new Random();
final List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 100000; i++) {
    Thread thread = new Thread() {
        @Override
        public void run() {
            list.add(random.nextInt());

        }
    };
    thread.start();
}
System.out.println("时间：" + (System.currentTimeMillis() - start));


时间：14729

线程池：

Long start = System.currentTimeMillis();
final Random random = new Random();
final List<Integer> list = new ArrayList<Integer>();
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 100000; i++) {
    executorService.execute(new Runnable() {
        @Override
        public void run() {
            list.add(random.nextInt());
        }
    });
}
executorService.shutdown();
System.out.println("时间："+(System.currentTimeMillis() - start));

时间：21

通过上面两种方式，我们明显的可以看出来，创建多个线程和使用线程池之间有明显的性能差别，造成这种情况的本质原因在于线程对于操作系统来说是一个比较重的资源，它的创建和销毁都需要额外花费CPU很多时间。而线程池可以通过线程复用避免了大量创建线程时的消耗，从而实现高性能的目的

二、线程池创建

Executors类提供这四种创建线程的，但这四种方式我们都不推荐使用，因为使用这种方式创建的线程池，线程池的相关参数都是采用默认的，很容易出现程序OOM的情况，所以我们更推荐使用new关键字来创建线程池，同时手动指定线程池的配置参数

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(10);

我们可以看一下上面这四个方法的源码，就直到如何创建一个线程池了

  • newSingleThreadExecutor

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

  • newCachedThreadPool

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

  • newFixedThreadPool

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

  • newScheduledThreadPool

    public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

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

从上面这几个这个方法的源码可以看出来，它们内部都是去New一个ThreadPoolExecutor实例，只是每种方法对应的参数不同而已，推荐直接使用这种方式来创建线程池。

三、线程池核心参数

所有创建线程池的方式，最后都会调用到下面这个构造方法，我们按照该方法的入参进行介绍

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;
}

3.1 corePoolSize

核心线程数(常驻线程数)，当线程池添加任务的时候，只要当前线程池中的线程数量没有达到核心线程数，都会创建一个新的线程来执行任务。当所有任务都执行完了之后，如果线程池中的线程数大于核心线程数，那么多出来的这部分线程，就会被销毁，而只保留核心线程数量的线程供后续使用。

3.2 maximumPoolSize

顾名思义，就是线程池中允许同时存在的最大线程数，当任务数量大于核心线程数时，新的任务会先添加到队列中进行等待，当队列也满了的时候，就会去判断当前线程池的线程数是否大于线程池允许的最大线程数，如果小于最大线程数，就会为这些任务创建新的线程，而这些新的线程都是临时线程。

通过Executors创建线程池时，这个值通常被设置为Integer.MAX_VALUE，当任务量太多事，就会导致OOM

3.3 keepAliveTime&TimeUnit

这个参数指定了临时线程的存活时间，TimeUnit参数指定时间的单位，将传进来的时间转换成纳秒。maximumPoolSize参数中说明了任务队列满了之后创建临时线程，之所以是临时线程，就是因为当线程池的任务都执行完了之后，这些临时的线程就会被销毁，那么什么时候销毁就是keepAliveTime参数决定的，超过这个时间后就会被销毁

同时这个参数也可以用于核心线程，如果线程池配置了allowCoreThreadTimeOut参数为true，表示如果核心线程等待时间超过了keepAliveTime，也会被回收

3.4 BlockingQueue

阻塞队列，向线程池添加任务时，如果线程池中的线程数已经达到核心线程数，那么新添加进来的任务就会先缓存到阻塞队列中，当某个线程的任务执行完了之后，再从阻塞队列获取任务继续执行。

Executors类中的四种创建线程池的方法分别用到了LinkedBlockingQueue、SynchronousQueue和DelayedWorkQueue

SynchronousQueue是一个同步队列，它并不会存储任务，当线程put一个任务后，该线程就会被阻塞，直到有线程调用take()方法，被阻塞的线程的才会被唤醒，它实现的是线程之间一对一传递消息的模型，而newCachedThreadPool()就是采用这种队列，就会导致一个现象就是，当线程数达到核心线程数后，当有新的任务进来后，就会被阻塞，需要创建一个新的线程来接收刚才的任务，否则就不能再添加任务。

LinkedBlockingQueue是一种链表式的阻塞队列，但它是一个有界队列，我们通过newSingleThreadExecutor()方法创建线程池时，直接new LinkedBlockingQueue<Runnable>()来创建阻塞队列，但这个阻塞队列默认的容量为Integer.MAX_VALUE，这也是导致程序出现OOM的原因之一，所以我们在创建阻塞队列的时候，一定要指定其容量。

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

DelayedWorkQueue是一个延时队列，主要用在定时的线程池中，它提供了默认的初始化容量为16，并且可以扩容

private static final int INITIAL_CAPACITY = 16;

private void grow() {
    int oldCapacity = queue.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // grow 50%
    if (newCapacity < 0) // overflow
        newCapacity = Integer.MAX_VALUE;
    queue = Arrays.copyOf(queue, newCapacity);
}

3.5 ThreadFactory

线程工厂，线程池中都是通过ThreadFactory的newThread()方法创建线程对象，Executors的四种的方法中，都是用DefaultThreadFactory作为线程工厂

3.6 RejectedExecutionHandler

拒接策略，即当任务数填满了阻塞队列，并且当前线程数已经达到线程池规定的最大线程数时，再有新的任务进来，就要采用相应的拒绝策略来处理新的任务。

ThreadPoolExecutor中提供了四种拒绝策略：

Java 线程池详解(上)

CallerRunsPolicy：由调用线程池的execute()方法的线程来执行当前任务

AbortPolicy：直接抛出RejectedExecutionException异常

DiscardPolicy：忽略该任务，不做任何处理

DiscardOldestPolicy：移除任务队列中待的最久的任务，然后重新提交

ThreadPoolExecutor中使用AbortPolicy作为默认的拒绝策略，但在实际开发中，一般会采用自己去实现RejectedExecutionHandler接口，自定义拒绝策略

3.7 其他核心参数

除了上面这些创建线程池时指定的参数外，线程池还有一些其他的核心参数，比如记录线程池状态、线程数量

ThreadPoolExecutor中通过INT类型的ctl属性来同时记录线程池状态和线程数量，其中高三位用来记录线程池状态，用低29位来记录线程池中线程数量

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

线程池状态的变迁图如下：

Java 线程池详解(上)

shutdown()和shutdownNow()方法区别在于：

线程池执行完shutdown()方法后，不能再继续向线程池添加任务，但已经添加的任务会继续执行；而执行完shutdownNow()方法之后，不仅不能向线程池添加任务，已经添加的任务也不会再执行，该方法内部会去中断所有线程

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/153633.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！