java线程池复习

最新推荐文章于 2024-04-19 03:20:42 发布

narkang

最新推荐文章于 2024-04-19 03:20:42 发布

阅读量459

点赞数 1

分类专栏： # java面试基础 # 高并发

本文链接：https://blog.csdn.net/qq_18242391/article/details/81292912

版权

高并发同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

java面试基础

3 篇文章 0 订阅

订阅专栏

在操作系统中，线程是操作系统调度的最小单位，同时线程又是一种受限的系统资源，即线程不可能无限地产生，并且线程的创建和销毁都会有相应的开销。所以就有了线程池的引入，它可以避免因为频繁创建和销毁线程所带来的系统开销。Android中的线程来源于java，主要是通过java1.5之后的Executor来派生特定的线程池。

优点：
(1).重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。
(2).能有效地控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象。
(3).能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能。

Executor接口的真正实现为ThreadPoolExecutor，通过配置它的参数可以创建各种线程池。在介绍线程池的种类之前，先需要介绍下该类中每个参数的作用。

一、ThreadPoolExecutor

它有四个构造函数提供我们实例化，最多的构造方法有七个

//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
                     int maximumPoolSize,
                     long keepAliveTime,
                     TimeUnit unit,
                     BlockingQueue<Runnable> workQueue,
                     ThreadFactory threadFactory,
                     RejectedExecutionHandler handler)

1.核心线程 corePoolSize

线程池新建线程时，如果当前线程总数小于核心线程 corePoolSize，则新建核心线程，如果超过corePoolSize，则新建非核心线程。

核心线程默认是一直在存活在线程池中，即使处于闲置状态。

如果指定 ThreadPoolExecutor 的 allowCoreThreadTimeOut 这个属性为 true，那么核心线程如果处于闲置状态的话，超过一定时间(keepAliveTime)，就会被销毁掉。

2.线程总数 maximumPoolSize

线程中的最大线程数，等于核心线程加上非核心线程。

3.超时时间 keepAliveTime

非核心线程超时时长，一个非核心线程的闲置时间超过这个线程设置的时长，就会被销毁。同时如果设置allowCoreThreadTimeOut = true，则也会作用于核心线程。

4 . 时间单位

keepAliveTime 的时间单位 TimeUnit ，枚举值，有以下几种：

NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ：秒
MINUTES ：分
HOURS ：小时
DAYS ：天

5 . 队列 BlockingQueue

它是一个接口，代表一个任务队列，也可以说是一个阻塞队列，维护着等待执行的runnable, 当所有的核心线程创建之后，就会将待执行的任务存入任务队列，如果任务队列满了，则创建非核心线程，根据具体的实现，有不同的使用情形，下面是常用的任务队列实现。

SynchronousQueue任务队列接受任务时，把任务直接提交给线程处理，如果所有线程都在工作，那就新创建一个线程来处理，所以此种任务队列一般需要设置maximumPoolSize为 Integer.MAX_VALUE，以防出现不能新建线程产生错误。

LinkedBlockingQueue任务队列接受任务时候，如果当前线程数小于核心线程数，则新建核心线程处理任务，如果当前线程数等于核心线程数，则进入队列等待，由于这个任务队列没有最大值限制，则所有超过核心线程都会被添加到队列中，这也就导致了maximumPoolSize 的设定失效，线程总数不会超过corePoolSize

ArrayBlockingQueue限定任务队列的长度，接受到任务时候，如果没有达到corePoolSize 的值，则新建核心线程执行任务，如果已经达到了，则入队列等待，如果队列已经满了，则新建非核心线程执行任务，如果线程总数达到了maximumPoolSize，则发生错误

DelayQueue队列内元素必须实现Delayed 接口，这就表示你传进去的任务必须实现Delayed 接口，入队列的元素，首先会先入队列，只有达到了指定的延时时间，才会执行任务

6 . ThreadFactory

创建线程的方式，Executors 有默认的ThreadFactory创建方式，一般没有特别需求可以直接使用它的默认实现方式，调用者不需要做操作，提交的任务通过它创建线程

/**
     * The default thread factory.
     */
    private static class DefaultThreadFactory implements ThreadFactory {
...
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

7 . RejectedExecutionHandler

抛出异常专用，也就是线程池的饱和策略，ThreadPoolExecutor 实现了几种常用异常

ThreadPoolExecutor.AbortPolicy:默认的策略，丢弃任务并抛出RejectedExecutionException异常，这种策略需要加try catch，否则程序会直接退出
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常，空方法。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）。
ThreadPoolExecutor.CallerRunsPolicy 在调用execute的线程里面执行此策略，会阻塞入口
用户自定义饱和策略（最常用）
实现RejectedExecutionHandler，并自己定义策略模式

二、添加线程规则

这里借鉴下这个大神的图

这里写图片描述

该图展示了ThreadPoolExecutor 下线程池的执行流程，关于线程池详细源码分析以及使用过程，可以看这篇文章

线程执行处理流程步骤：
(1).提交任务后，线程池先判断线程数是否达到了核心线程总数，如果未达到核心线程总数，则创建核心线程数；否则执行下一步骤
(2).接着线程池判断任务队列是否满了。如果没满，则将任务添加到任务队列中；否者，则执行下一步操作。
(3).接着因为任务队列满了，线程池就判断线程数是否达到了最大线程数。如果未达到，则创建非核心线程处理任务。否则执行饱和策略，默认抛出RejectedExecutionHandler异常

三、常见的四种线程池

Executors默认给我们提供了几种线程池，常用的有四种，都是通过ThreadPoolExecutor 直接或者间接实现的，调用者可以很方便的使用它

1 . CachedThreadPool

创建方法：

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

借助下Android进阶之光的图来看下它的执行流程
这里写图片描述

这个线程池没有核心线程，线程总数为Integer.MAX_VALUE，线程存活时间为60s，用到了阻塞队列SynchronousQueue ，是一个不存储元素的队列，一个元素的插入必须等另一个元素的移除操作。当执行execute 方法首先执行SynchronousQueue的offer方法提交任务，然后查询线程池是否有空闲线程，执行任务，有就将任务交给空闲线程执行任务，没有就新创建非核心线程，然后调用poll来移除任务，交给线程处理任务。当线程空闲时候，就会调用poll 等待任务的提交，如果60s空闲线程没有处理任务就会被终止。

好处：

1.线程无限制
2.有空闲线程则复用空闲线程，若无空闲线程则新建线程
3.一定程序减少频繁创建/销毁线程，减少系统开销
4.适合执行大量的耗时较少的任务

缺点:

这里的弊端在于第二个参数maximumPoolSize被设置为了Integer.MAX_VALUE, 这可能会创建数量非常多的线程,甚至导致OOM.

2 . FixedThreadPool

创建方法：

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

这里写图片描述

只有核心线程，线程总数是一定的，采用了无界的阻塞队列LinkedBlockingQueue，当执行execute方法时候，如果当前线程总数没有超过核心线程总数，就会创建核心线程，否则就会将任务提交给队列，当核心线程有空闲的时候，就回去任务队列中取任务执行。

好处：

1.可控制线程最大并发数（同时执行的线程数）
2.超出的线程会在队列中等待
3.由于都是核心线程，能够更快的响应外界请求

缺点:
由于传进去的LinkedBlockingQueue是没有容量上限的,所以当请求数越来越多时,并且无法及时处理完毕的时候,也就是请求堆积的时候,会容易造成占用大量的内存,可能会导致OOM.

3 . ScheduledThreadPool

创建方法：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

这里写图片描述

执行ScheduledThreadPoolExecutor的scheduleAtFixedRate或者scheduledWithFixedDelay方法时候，会向DelayWorkQueue添加一个实现RunableScheduledFuture接口的ScheduledFutureTask任务包装类，并会检查运行的线程是否达到了核心线程，如果没有则新建线程启动它，单不会立即执行，而是去DelayWorkQueue中取ScheduledFutureTask然后执行异步任务。如果达到核心线程，则将任务添加到DelayWorkQueue，它会将任务进行排序，并会将ScheduledFutureTask的time变量改为下次要执行的时间并放回DelayWorkQueue中

好处：

1 . 这个线程池支持定时或者具有固定周期的重复性任务

4 . SingleThreadExecutor

创建方法：

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

这里写图片描述

只有一个核心线程，其它流程和FixedThreadPool 一样。

好处：

1.有且仅有一个工作线程执行任务
2.所有任务按照指定顺序执行，即遵循队列的入队出队规则

关于这几种线程池的原理，可以看这篇文章

四、Android中线程池的使用

作为一名Android开发者，在平时我们开发中，使用的原生API或者第三方库，都会或多或少使用线程池，下面举出几个我在平时开发中使用到线程池的地方。

1 . EventBus中线程池的使用

熟悉EventBus源码的人都会知道，它里面有三个Poster，不熟悉的看这里，它在EventBus中起到一个线程切换的作用，同时也提供一个线程去执行异步任务。其中它们的默认使用如下

private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();

可以看见创建了一个CachedThreadPool，这个线程池都是非核心线程，可以在一定程度上减轻频繁创建线程所带来的线程开销。

关于它的源码可以看张拭心的EventBus文章

2 . Okhttp中线程池的使用

在Okhttp中有个分发器Dispatcher，在里面维护了一个executorService，它的创建如下：

public synchronized ExecutorService executorService() {
 if (executorService == null) {
   executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
       new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
 }
 return executorService;
}

它是完全自定义的ThreadPoolExecutor，可以看见它的核心线程为0，非核心线程设置为
Integer.MAX_VALUE和和EventBus的线程数一样

关于它的源码可以看张拭心的okhttp这篇文章，挺详细的

3 . AsyncTask中线程池的使用

刚学Android的时候，这个AsyncTask 作为异步任务的API 用得还是比较广的，它里面封装了线程池和Handler，在异步任务和UI线程中切换非常方便，看下其线程池的使用

private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
    }

它的核心线程是Math.max(2, Math.min(CPU_COUNT - 1, 4))， CPU_COUNT 是CPU的数，也就是CPU核心数+1，总线程总数是CPU_COUNT * 2 + 1，而它的任务队列是new LinkedBlockingQueue<Runnable>(128)，这样它的任务队列的最大长度是128。这样就达到了控制线程的并发数，当线程达到最大核心线程数时候，其它任务就会被放到任务队列中。

还有很多地方也用到了线程池，就不一一举例了。

关于它的源码可以看Android开发者进阶，或者Android开发者艺术探索，都有它的源码讲解

五、增减线程特点

1、通过设置corePoolSize和maximumPoolSize相同，就可以创建固定大小的线程池
2、线程池希望保持较少的线程数，并且只有负载变得很大时才增加它
3、通过设置maximumPoolSize为很高的值，例如Integer.VALUE，可以允许线程池容纳任意数量的并发任务
4、是只有在队列填满时才创建多于corePoolSize的线程，所以如果你使用的是无界队列（例如LinkedBlockingQueue），那么线程数不会超过corePoolSize。

六、钩子方法

可以在每个任务前后，加功能，比如日志，统计

public class PauseableThreadPool extends ThreadPoolExecutor {

    private final ReentrantLock lock = new ReentrantLock();
    private Condition unpaused = lock.newCondition();
    private boolean isPaused;


    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit,
            BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue,
            ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue,
            RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue,
            ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory,
                handler);
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        lock.lock();
        try {
            while (isPaused) {
                unpaused.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    private void pause() {
        lock.lock();
        try {
            isPaused = true;
        } finally {
            lock.unlock();
        }
    }

    public void resume() {
        lock.lock();
        try {
            isPaused = false;
            unpaused.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        PauseableThreadPool pauseableThreadPool = new PauseableThreadPool(10, 20, 10l,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我被执行");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 10000; i++) {
            pauseableThreadPool.execute(runnable);
        }
        Thread.sleep(1500);
        pauseableThreadPool.pause();
        System.out.println("线程池被暂停了");
        Thread.sleep(1500);
        pauseableThreadPool.resume();
        System.out.println("线程池被恢复了");

    }
}

七、停止线程的正确方法

1、shutdown 关闭线程池，正在执行的任务还会执行，没执行的任务不会执行了
2、isShutdown 判断线程池是否进入停止状态了
3、isTerminated 判断线程是否开始，所有任务是否停止完了
4、awaitTermination 一段时间内任务是否执行完成
5、shutdownNow 立刻关闭线程池会返回未被执行完的线程

八、线程池的线程数量设定为多少比较合适？

CPU密集型（加密、计算hash等）：最佳线程数为CPU核心数的1-2倍左右
耗时IO型（读写数据库、文件、网络读写等）：最佳线程数一般会大于CPU核心数很多倍，以JVM线程监控显示繁忙情况为依据，保证线程空闲可以衔接上，参考Brain Goetz推荐的计算方法：

线程数=CPU核心数*（1+平均等待时间/平均工作时间）

九、线程池手动创建还是自动创建更好？

手动创建更好，因为这样可以让我们更加明确线程池的运行规则，避免资源耗尽的风险。

自动创建线程池可能带来的问题上面已经介绍了

十、线程池状态和使用注意点

状态：
1、RUNNING:接受新任务并处理排队任务
2、SHUTDOWN：不接受新任务，但处理排队任务
3、STOP：不接受新任务，也不处理排队任务，并中断正在进行的任务
4、TIDYING：中文是整洁，理解了中文就容易理解这个状态了：所有任务都已终止，workerCount为零时，线程会转换到TIDYING状态，并将terminate()运行完成。
5、TERMINATED:terminate()运行完成

注意点：
1、避免任务堆积
2、避免线程数过度增加
3、排查线程泄漏