Android 线程池

2019-03-20 本文已影响0人落叶随风花开半夏

1.含义

线程池用于多线程处理中，它可以根据系统的情况，可以有效控制线程执行的数量，优化运行效果。线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

2.优缺点

new Thread 的缺点

每次new thread创建新的对象,性能差
线程缺乏统一管理,能无限创建新线程,造成资源过多占用(死机)或OOM
缺乏更多功能,如:定时执行,定期执行,线程中断

java提供的线程池的优点

重用存在的线程,减少线程创建,销毁的销毁,性能佳
可有效的控制线程并发的最大数,提高资源使用率,同时避免过多资源竞争，避免堵塞。
提供定时执行、定期执行、单线程、并发控制等功能

3.实现类

ThreadPoolExecutor类 = 线程池的真正实现类

开发者可根据不同需求配置核心参数，从而实现自定义线程池

// 创建线程池对象如下
// 通过 构造方法 配置核心参数
Executor executor = new ThreadPoolExecutor( 
                                          CORE_POOL_SIZE,
                                          MAXIMUM_POOL_SIZE,
                                          KEEP_ALIVE,
                                          TimeUnit.SECONDS, 
                                          sPoolWorkQueue,
                                          sThreadFactory 
                                           );

// 构造函数源码分析
public ThreadPoolExecutor (int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

构造方法里面参数意义作用

corePoolSize: 线程池中核心线程的数量。
maximumPoolSize: 线程池中最大线程数量。
keepAliveTime: 非核心线程的超时时长，超过该时长,非核心线程就会被回收。 如果ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，则该参数也表示核心线程的超时时长。
unit: keepAliveTime这个参数的单位，有纳秒、微秒、毫秒、秒、分、时、天等。
workQueue: 线程池中的任务队列，该队列主要用来存储已经被提交但是尚未执行的任务。存储在这里的任务是由ThreadPoolExecutor的execute方法提交来的。
threadFactory: 为线程池提供创建新线程的功能，这个我们一般使用默认即可。
handler: 拒绝策略，当线程无法执行新任务时（一般是由于线程池中的线程数量已经达到最大数或者线程池关闭导致的），默认情况下，当线程池无法处理新线程时，会抛出一个RejectedExecutionException。

任务队列

LinkedBlockingQueue：

LinkedBlockingQueue是我们在ThreadPoolExecutor线程池中常用的等待队列。它可以指定容量也可以不指定容量。由于它具有“无限容量”的特性，所以我还是将它归入了无限队列的范畴（实际上任何无限容量的队列/栈都是有容量的，这个容量就是Integer.MAX_VALUE）。
LinkedBlockingQueue的实现是基于链表结构，而不是类似ArrayBlockingQueue那样的数组。但实际使用过程中，不需要关心它的内部实现，如果指定了LinkedBlockingQueue的容量大小，那么它反映出来的使用特性就和ArrayBlockingQueue类似了。

LinkedBlockingDeque

LinkedBlockingDeque是一个基于链表的双端队列。LinkedBlockingQueue的内部结构决定了它只能从队列尾部插入，从队列头部取出元素；但是LinkedBlockingDeque既可以从尾部插入/取出元素，还可以从头部插入元素/取出元素。

PriorityBlockingQueue

PriorityBlockingQueue是一个按照优先级进行内部元素排序的无限队列。存放在PriorityBlockingQueue中的元素必须实现Comparable接口，这样才能通过实现compareTo()方法进行排序。优先级最高的元素将始终排在队列的头部；PriorityBlockingQueue不会保证优先级一样的元素的排序，也不保证当前队列中除了优先级最高的元素以外的元素，随时处于正确排序的位置。

LinkedTransferQueue

LinkedTransferQueue也是一个无限队列，它除了具有一般队列的操作特性外（先进先出），还具有一个阻塞特性：LinkedTransferQueue可以由一对生产者/消费者线程进行操作，当消费者将一个新的元素插入队列后，消费者线程将会一直等待，直到某一个消费者线程将这个元素取走，反之亦然。
LinkedTransferQueue的操作特性可以由下面这段代码提现。在下面的代码片段中，有两中类型的线程：生产者和消费者，这两类线程互相等待对方的操作：

handler拒绝策略

线程池对拒绝任务的处理策略。一般是队列已满或者无法成功执行任务，这时ThreadPoolExecutor会调用handler的rejectedExecution方法来通知调用者

ThreadPoolExecutor默认有四个拒绝策略：

1、ThreadPoolExecutor.AbortPolicy()   直接抛出异常RejectedExecutionException
2、ThreadPoolExecutor.CallerRunsPolicy()    直接调用run方法并且阻塞执行
3、ThreadPoolExecutor.DiscardPolicy()   直接丢弃后来的任务
4、ThreadPoolExecutor.DiscardOldestPolicy()  丢弃在队列中队首的任务

4.常见的4类功能线程池

根据参数的不同配置，Java中最常见的线程池有4类：

定长线程池（FixedThreadPool）
定时线程池（ScheduledThreadPool ）
可缓存线程池（CachedThreadPool）
单线程化线程池（SingleThreadExecutor）

即对于上述4类线程池，Java已根据应用场景配置好核心参数

4.1 定长线程池（FixedThreadPool）

特点:只有核心线程 & 不会被回收、线程数量固定、任务队列无大小限制（超出的线程任务会在队列中等待）
应用场景：控制线程最大并发数
具体使用：通过 Executors.newFixedThreadPool() 创建

示例：

  // 1. 创建定长线程池对象 & 设置线程池线程数量固定为3
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  
  // 2. 创建好Runnable类线程对象 & 需执行的任务
  Runnable task =new Runnable(){
    public void run(){
      System.out.println("执行任务啦");
       }
      };
          
  // 3. 向线程池提交任务：execute（）
  fixedThreadPool.execute(task);
          
  // 4. 关闭线程池
  fixedThreadPool.shutdown();

4.2 定时线程池（ScheduledThreadPool ）

特点：核心线程数量固定、非核心线程数量无限制（闲置时马上回收）
应用场景：执行定时 / 周期性任务
使用：通过Executors.newScheduledThreadPool()创建

示例：

  // 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  
  // 2. 创建好Runnable类线程对象 & 需执行的任务
  Runnable task =new Runnable(){
         public void run(){
                System.out.println("执行任务啦");
            }
      };
  // 3. 向线程池提交任务：schedule（）
  scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
  scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务
  
  // 4. 关闭线程池
  scheduledThreadPool.shutdown();

4.3 可缓存线程池（CachedThreadPool）

特点：只有非核心线程、线程数量不固定（可无限大）、灵活回收空闲线程（具备超时机制，全部回收时几乎不占系统资源）、新建线程（无线程可用时）

任何线程任务到来都会立刻执行，不需要等待

应用场景：执行大量、耗时少的线程任务
使用：通过Executors.newCachedThreadPool()创建

示例：

  // 1. 创建可缓存线程池对象
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  
  // 2. 创建好Runnable类线程对象 & 需执行的任务
  Runnable task =new Runnable(){
    public void run(){
          System.out.println("执行任务啦");
              }
      };

  // 3. 向线程池提交任务：execute（）
  cachedThreadPool.execute(task);

  // 4. 关闭线程池
  cachedThreadPool.shutdown();

  //当执行第二个任务时第一个任务已经完成
  //那么会复用执行第一个任务的线程，而不用每次新建线程。

4.4 单线程化线程池（SingleThreadExecutor）

特点：只有一个核心线程（保证所有任务按照指定顺序在一个线程中执行，不需要处理线程同步的问题）
应用场景：不适合并发但可能引起IO阻塞性及影响UI线程响应的操作，如数据库操作，文件操作等
使用：通过Executors.newSingleThreadExecutor()创建

示例：

  // 1. 创建单线程化线程池
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  
  // 2. 创建好Runnable类线程对象 & 需执行的任务
  Runnable task =new Runnable(){
    public void run(){
          System.out.println("执行任务啦");
              }
      };
  
  // 3. 向线程池提交任务：execute（）
  singleThreadExecutor.execute(task);
  
  // 4. 关闭线程池
  singleThreadExecutor.shutdown();