Android线程池简介_android 什么是线程池

应用开发过程中，难免接触线程池概念

写篇文章记录下

1. 线程池简介

线程池就是首先创建一些线程，它们的集合称为线程池。

使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

2. 线程池工作机制

在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程

一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务

3. 线程池的优势

多线程运行时，系统不断的启动和关闭新线程，成本非常高，会过度消耗系统资源，以及过度切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了

• 重用已经创建的好的线程，避免频繁创建进而导致的频繁GC
• 控制线程并发数，合理使用系统资源，提高应用性能
• 可以有效的控制线程的执行，比如定时执行，取消执行等

4. 四种常见的线程池详解(ExecutorService简介)

ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程

1. Executors.newCachedThreadPool()

可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务

// 创建一个可缓存线程池
// 线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            try {
                // sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    // 打印正在执行的缓存线程信息
                    System.out.println(Thread.currentThread().getName()+"正在被执行");
                }
            });
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. Executors.newFixedThreadPool(int n)

创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程

		// 创建一个可重用固定个数的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        // 打印正在执行的缓存线程信息
                        System.out.println(Thread.currentThread().getName()+"正在被执行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果。
PS：定长线程池的大小最好根据系统资源进行设置。如：Runtime.getRuntime().availableProcessors()

3. Executors.newScheduledThreadPool(int n)

创建一个定长线程池，支持定时及周期性任务执行

// 创建一个定长线程池，支持定时及周期性任务执行——延迟执行
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
	// 延迟1秒执行
	scheduledThreadPool.schedule(new Runnable() {
		public void run() {
			System.out.println("延迟1秒执行");
		}
	}, 1, TimeUnit.SECONDS);
1
2
3
4
5
6
7
8

4. Executors.newSingleThreadExecutor()

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

		// 创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        // 结果依次输出，相当于顺序执行各个任务
                        System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• FIFO（First Input First Output）：即先进先出队列
• LIFO （Last in, First out）：后进先出

5. Android中常用的线程池都是通过对ThreadPoolExecutor进行不同配置来实现的

ThreadPoolExecutor有四个重载的构造方法，我们这里来说说参数最多的那一个重载的构造方法，这样大家就知道其他方法参数的含义了

/**
     * @param corePoolSize    线程池中核心线程的数量
     * @param maximumPoolSize 线程池中最大线程数量
     * @param keepAliveTime   非核心线程的超时时长，当系统中非核心线程闲置时间超过keepAliveTime之后，则会被回收。
     *                        如果ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，则该参数也表示核心线程的超时时长
     * @param unit            第三个参数的单位，有纳秒、微秒、毫秒、秒、分、时、天等
     * @param workQueue       线程池中的任务队列，该队列主要用来存储已经被提交但是尚未执行的任务。
     *                        存储在这里的任务是由ThreadPoolExecutor的execute方法提交来的
     * @param threadFactory   为线程池提供创建新线程的功能，这个我们一般使用默认即可
     * @param handler         拒绝策略，当线程无法执行新任务时（一般是由于线程池中的线程数量已经达到最大数或者线程池关闭导致的），
     *                        默认情况下，当线程池无法处理新线程时，会抛出一个RejectedExecutionException
     */
    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

6. 缓冲队列 BlockingQueue 和自定义线程池 ThreadPoolExecutor

1. 缓冲队列BlockingQueue简介

BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率

常用的几种BlockingQueue

1. ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的
2. LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的
3. PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定
4. SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成

7. 针对于workQueue多说几点

workQueue是一个BlockingQueue类型，那么这个BlockingQueue又是什么呢？

它是一个特殊的队列，当我们从BlockingQueue中取数据时，如果BlockingQueue是空的，则取数据的操作会进入到阻塞状态，当BlockingQueue中有了新数据时，这个取数据的操作又会被重新唤醒。同理，如果BlockingQueue中的数据已经满了，往BlockingQueue中存数据的操作又会进入阻塞状态，直到BlockingQueue中又有新的空间，存数据的操作又会被冲洗唤醒。BlockingQueue有多种不同的实现类，下面我举几个例子来说一下：

• 1.ArrayBlockingQueue：这个表示一个规定了大小的BlockingQueue，ArrayBlockingQueue的构造函数接受一个int类型的数据，该数据表示BlockingQueue的大小，存储在ArrayBlockingQueue中的元素按照FIFO（先进先出）的方式来进行存取。
• 2.LinkedBlockingQueue：这个表示一个大小不确定的BlockingQueue，在LinkedBlockingQueue的构造方法中可以传一个int类型的数据，这样创建出来的LinkedBlockingQueue是有大小的，也可以不传，不传的话，LinkedBlockingQueue的大小就为Integer.MAX_VALUE
• 3.PriorityBlockingQueue：这个队列和LinkedBlockingQueue类似，不同的是PriorityBlockingQueue中的元素不是按照FIFO来排序的，而是按照元素的Comparator来决定存取顺序的（这个功能也反映了存入PriorityBlockingQueue中的数据必须实现了Comparator接口）。
• 4.SynchronousQueue：这个是同步Queue，属于线程安全的BlockingQueue的一种，在SynchronousQueue中，生产者线程的插入操作必须要等待消费者线程的移除操作，Synchronous内部没有数据缓存空间，因此我们无法对SynchronousQueue进行读取或者遍历其中的数据，元素只有在你试图取走的时候才有可能存在。我们可以理解为生产者和消费者互相等待，等到对方之后然后再一起离开。

ThreadPoolExecutor在提交到线程池之后又是按照什么样的规则去运行呢？OK，它们遵循如下规则：

• 1.execute一个线程之后，如果线程池中的线程数未达到核心线程数，则会立马启用一个核心线程去执行
• 2.execute一个线程之后，如果线程池中的线程数已经达到核心线程数，且workQueue未满，则将新线程放入workQueue中等待执行
• 3.execute一个线程之后，如果线程池中的线程数已经达到核心线程数但未超过非核心线程数，且workQueue已满，则开启一个非核心线程来执行任务
• 4.execute一个线程之后，如果线程池中的线程数已经超过非核心线程数，则拒绝执行该任务

自定义线程池（ThreadPoolExecutor和BlockingQueue连用）

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池

class TempThread implements Runnable {

    @Override
    public void run() {
        // 打印正在执行的缓存线程信息
        System.out.println(Thread.currentThread().getName() + "正在被执行");
        try {
            // sleep一秒保证3个任务在分别在3个线程上执行
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 		// 创建数组型缓冲等待队列
        BlockingQueue<Runnable> bq = new ArrayBlockingQueue<Runnable>(10);
        // ThreadPoolExecutor:创建自定义线程池，池中保存的线程数为3，允许最大的线程数为6
        ThreadPoolExecutor tpe = new ThreadPoolExecutor(3, 6, 50, TimeUnit.MILLISECONDS, bq);

        // 创建3个任务
        Runnable t1 = new TempThread();
        Runnable t2 = new TempThread();
        Runnable t3 = new TempThread();
        // Runnable t4 = new TempThread();
        // Runnable t5 = new TempThread();
        // Runnable t6 = new TempThread();

        // 3个任务在分别在3个线程上执行
        tpe.execute(t1);
        tpe.execute(t2);
        tpe.execute(t3);
        // tpe.execute(t4);
        // tpe.execute(t5);
        // tpe.execute(t6);

        // 关闭自定义线程池
        tpe.shutdown();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

6. 参考

1. 线程池之ThreadPoolExecutor使用
2. 如何停止被BlockingQueue阻塞的线程
3. 阻塞队列（BlockingQueue）方法介绍
4. AsyncTask不同版本线程池的区别
5. Android AsyncTask(1)-使用方法和线程池解析
6. 线程池的优雅关闭实践
7. 线程池之ThreadPoolExecutor使用
8. 线程启动原理
9. 线程池之ThreadPoolExecutor概述