Android中线程池

一、线程池的优点
说到线程池的优点就要先说一下不用线程池的坏处

• 在早些年开发都是直接new Thread()直接创建线程，倘若有N个异步就要创建N个线程，这会导致线程的频繁创建和销毁
• 线程不可控，每个线程都各自执行，内存资源竞争激烈，这可能会导致OOM

使用线程池的好处

• 不用频繁创建线程，可重用线程池中的线程，免去了频繁创建的性能开销
• 可控制线程的最大并发，超过一定数量的线程进入队列等待执行

二、线程池的使用​​​​​​​

1：ThreadPoolExecutor 创建基本线程池

创建线程池，主要是利用ThreadPoolExecutor这个类，而这个类有几种构造方法，其中参数最多的一种构造方法如下：

1. public ThreadPoolExecutor(int corePoolSize,
2. int maximumPoolSize,
3. long keepAliveTime,
4. TimeUnit unit,
5. BlockingQueue<Runnable> workQueue,
6. ThreadFactory threadFactory) {
7. ...
8. }

corePoolSize: 该线程池中核心线程的数量。

注意：线程池中存在核心线程与非核心线程，核心线程一旦创建会一直执行任务或等待任务到来，而非核心线程只在任务队列塞满任务时去执行多出的任务，并且非核心线程在等待一段时间后将会被回收，这个时间作为参数可调配，见下面的keepAliveTime参数。

maximumPoolSize：该线程池中最大线程数量。(区别于corePoolSize)

keepAliveTime:从字面上就可以理解，是非核心线程空闲时要等待下一个任务到来的时间，当任务很多，每个任务执行时间很短的情况下调大该值有助于提高线程利用率。注意：当allowCoreThreadTimeOut属性设为true时，该属性也可用于核心线程。

unit:上面时间属性的单位

workQueue:任务队列，后面详述。

threadFactory:线程工厂，可用于设置线程名字等等，一般无须设置该参数。

设置好几个参数就可以创建一个基本的线程池，而之后的各种线程池都是在这种基本线程池的基础上延伸的。

下面贴个自己写的demo来熟悉具体的使用并且加深影响：

1. //创建基本线程池
2. final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,5,1,TimeUnit.SECONDS,
3. new LinkedBlockingQueue<Runnable>(100));

设置一个按钮mThreadPoolExecute，并在点击事件中使用线程池

1. /**
2. * 基本线程池使用
3. */
4. mThreadPoolExecute.setOnClickListener(new View.OnClickListener() {
5. @Override
6. public void onClick(View v) {
8. for(int i = 0;i<30;i++){
9. final int finali = i;
10. Runnable runnable = new Runnable() {
11. @Override
12. public void run() {
13. try {
14. Thread.sleep(2000);
15. Log.d("Thread", "run: "+finali);
16. Log.d("当前线程：",Thread.currentThread().getName());
17. } catch (InterruptedException e) {
18. e.printStackTrace();
19. }
20. }
21. };
22. threadPoolExecutor.execute(runnable);
23. }
24. }
25. });

结果会每2s打印三个日志。

具体过程：

1.execute一个线程之后，如果线程池中的线程数未达到核心线程数，则会立马启用一个核心线程去执行。

2.execute一个线程之后，如果线程池中的线程数已经达到核心线程数，且workQueue未满，则将新线程放入workQueue中等待执行。

3.execute一个线程之后，如果线程池中的线程数已经达到核心线程数但未超过非核心线程数，且workQueue已满，则开启一个非核心线程来执行任务。

4.execute一个线程之后，如果线程池中的线程数已经超过非核心线程数，则拒绝执行该任务，采取饱和策略，并抛出RejectedExecutionException异常。

demo中设置的任务队列长度为100，所以不会开启额外的5-3=2个非核心线程，如果将任务队列设为25，则前三个任务被核心线程执行，剩下的30-3=27个任务进入队列会满，此时会开启2个非核心线程来执行剩下的两个任务。

1. //新开启了thread-4与thread-5执行剩下的超出队列的两个任务28和29
2. 2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/Thread:: 1
3. 2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/Thread:: 0
4. 2019-03-28 15:54:07.879 22284-22617/com.example.threadpooltest D/当前线程：: pool-1-thread-1
5. 2019-03-28 15:54:07.879 22284-22618/com.example.threadpooltest D/当前线程：: pool-1-thread-2
6. 2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/Thread:: 2
7. 2019-03-28 15:54:07.880 22284-22619/com.example.threadpooltest D/当前线程：: pool-1-thread-3
8. 2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/Thread:: 28
9. 2019-03-28 15:54:07.881 22284-22620/com.example.threadpooltest D/当前线程：: pool-1-thread-4
10. 2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/Thread:: 29
11. 2019-03-28 15:54:07.881 22284-22621/com.example.threadpooltest D/当前线程：: pool-1-thread-5

疑问：每个for循环里都有一个sleep（2000），为何会每隔2s打印三个任务？
原因：因为一开始的时候只是声明runnable对象并且重写run()方法，并没有运行，而后execute(runnable) 才会sleep，又因为一开始创建线程池的时候声明的核心线程数为3，所以会首先开启三个核心线程，然后执行各自的run方法，虽然有先后顺序，但这之间的间隔很短，所以2s后同时打印3个任务。

2：FixedThreadPool (可重用固定线程数)

Executors类中的创建方法：

FixedThreadPool创建

特点：参数为核心线程数，只有核心线程，无非核心线程，并且阻塞队列无界。

demo代码：

创建：

1. //创建fixed线程池
3. final ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

使用：

1. /**
2. * fixed线程池
3. */
4. mFixedPoolThread.setOnClickListener(new View.OnClickListener() {
5. @Override
6. public void onClick(View v) {
7. for(int i = 0;i<30;i++){
8. final int finali = i;
9. Runnable runnable = new Runnable() {
10. @Override
11. public void run() {
12. try {
13. Thread.sleep(2000);
14. Log.d("Thread", "run: "+finali);
15. Log.d("当前线程：",Thread.currentThread().getName());
16. } catch (InterruptedException e) {
17. e.printStackTrace();
18. }
19. }
20. };
21. fixedThreadPool.execute(runnable);
23. }
24. }
25. });

结果为每2s打印5次任务，跟上面的基础线程池类似。

3：CachedThreadPool (按需创建)

Executors类中的创建方法：

CachedThreadPool创建

特点：没有核心线程，只有非核心线程，并且每个非核心线程空闲等待的时间为60s，采用SynchronousQueue队列。

demo代码：

创建：

1. //创建Cached线程池
3. final ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

使用：

1. /**
2. * cached线程池
3. */
4. mCachedPoolThread.setOnClickListener(new View.OnClickListener() {
5. @Override
6. public void onClick(View v) {
7. for(int i = 0;i<30;i++){
8. final int finali = i;
9. Runnable runnable = new Runnable() {
10. @Override
11. public void run() {
12. try {
13. Thread.sleep(2000);
14. Log.d("Thread", "run: "+finali);
15. } catch (InterruptedException e) {
16. e.printStackTrace();
17. }
18. }
19. };
20. cachedThreadPool.execute(runnable);
22. }
23. }
24. });

结果：过2s后直接打印30个任务

结果分析：

• 因为没有核心线程，其他全为非核心线程，SynchronousQueue是不存储元素的，每次插入操作必须伴随一个移除操作，一个移除操作也要伴随一个插入操作。
• 当一个任务执行时，先用SynchronousQueue的offer提交任务，如果线程池中有线程空闲，则调用SynchronousQueue的poll方法来移除任务并交给线程处理；如果没有线程空闲，则开启一个新的非核心线程来处理任务。
• 由于maximumPoolSize是无界的，所以如果线程处理任务速度小于提交任务的速度，则会不断地创建新的线程，这时需要注意不要过度创建，应采取措施调整双方速度，不然线程创建太多会影响性能。
• 从其特点可以看出，CachedThreadPool适用于有大量需要立即执行的耗时少的任务的情况。

4：SingleThreadPool(单个核线的fixed)

创建方法：

SingleThreadPool创建

创建：

1. //创建Single线程池
2. final ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

使用：

1. /**
2. * single线程池
3. */
4. mSinglePoolExecute.setOnClickListener(new View.OnClickListener() {
5. @Override
6. public void onClick(View v) {
7. for(int i = 0;i<30;i++){
8. final int finali = i;x
9. Runnable runnable = new Runnable() {
10. @Override
11. public void run() {
12. try {
13. Thread.sleep(2000);
14. Log.d("Thread", "run: "+finali);
15. } catch (InterruptedException e) {
16. e.printStackTrace();
17. }
18. }
19. };
20. singleThreadExecutor.execute(runnable);
22. }
23. }
24. });

结果：每2s打印一个任务，由于只有一个核心线程，当被占用时，其他的任务需要进入队列等待。

5：ScheduledThreadPool(定时延时执行)

创建方法：

ScheduledThreadPool创建1

ScheduledThreadPool创建2

创建：

1. //创建Scheduled线程池
2. final ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

使用：

1. /**
2. * scheduled线程池
3. */
4. mScheduledTheadPool.setOnClickListener(new View.OnClickListener() {
5. @Override
6. public void onClick(View v) {
8. Runnable runnable = new Runnable() {
9. @Override
10. public void run() {
12. Log.d("Thread", "This task is delayed to execute");
13. }
15. };
16. scheduledThreadPool.schedule(runnable,10,TimeUnit.SECONDS);//延迟启动任务
18. //延迟5s后启动，每1s执行一次 scheduledThreadPool.scheduleAtFixedRate(runnable,5,1,TimeUnit.SECONDS);
19. //启动后第一次延迟5s执行，后面延迟1s执行 scheduledThreadPool.scheduleWithFixedDelay(runnable,5,1,TimeUnit.SECONDS);
20. }
21. });

结果如代码所述。

public class ThreadPool {
    /**
     * 线程池大小
     */
    static int corePoolSize = 10;
    /**
     * 线程池最大数量
     */
    static int maxmunPoolSize = 50;
    /**
     * 线程活动保持时间
     */
    static int keepAliveTime = 5;
    /**
     * 任务队列
     */
    static ArrayBlockingQueue workQueue = new ArrayBlockingQueue(10);

    private static ThreadPool threadPool;

    public static synchronized ThreadPool getInstance() {
        if (threadPool == null) {
            threadPool = new ThreadPool();
        }
        return threadPool;
    }

    public void exe(Runnable runnable) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                corePoolSize,
                maxmunPoolSize,
                keepAliveTime,
                TimeUnit.SECONDS,
                workQueue);
        threadPoolExecutor.execute(runnable);
    }
}