Android日记之线程池

作者 : 开心源码 本文共8842个字,预计阅读时间需要23分钟 发布时间: 2022-05-13 共243人阅读

前言

在编程中经常会使用线程来异步解决任务,但是每个线程的创立和销毁都需要肯定的开销。假如每次执行一个任务都需要一个新进程去执行,则这些线程的创立和销毁将消耗大量的资源;并且线程都是“各自为政”的,很难对其进行控制,更何况有一堆的线程在执行。这时候就需要线程池来对线程进行管理。在Java 1.5中提供了Executor框架用于把任务的提交和执行解耦。任务的提交交给RUnnable或者者Callable,而Executor框架用来解决任务。Executor框架中最核心的成员就是ThreadPoolExecutor,它是线程池的核心实现类。本篇文章就着重讲解ThreadPoolExecutor。

ThreadPoolExecutor详情

可以通过ThreadPoolExecutor开创立一个线程池,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.corePoolSize = corePoolSize;    this.maximumPoolSize = maximumPoolSize;    this.workQueue = workQueue;    this.keepAliveTime = unit.toNanos(keepAliveTime);    this.threadFactory = threadFactory;    this.handler = handler;}
  • corePoolSize:核心线程数。默认情况下线程池是空的,只有任务提交时才会创立线程。假如当前运行的线程数少于corePoolSize,则会创立新线程来解决任务;假如等于或者者多于corePoolSize,则不会创立,假如调用线程池的prestartAllcoreThread()方法,线程池会提前创立并启动所有核心线程来等待任务。

  • maximumPoolSize:线程池允许创立的最大线程数,假如任务队列满了并且线程数小于maximumPoolSize时,则线程池依旧会创立新的线程来解决任务。

  • keepAliveTime:非核心线程闲置的超时时间,超过这个事件则回收,假如任务很多,并且每个任务的执行事件很短,则可以调用keepAliveTime来提高线程的利用率。另外,假如设置allowCoreThreadTimeOut属性为true时,keepAliveTime也会应用到核心线程上。

  • TimeUnit:keepAliveTime参数的时间单位,可选的单位有天(DAYS)、小时(HOURS)、分钟(MINUTES)、秒(SECONDS)、毫秒(MILLOSECONDS)等。

  • BlockingQueue<Runnable> :任务队列,假如当前线程数大于corePoolSize,则将任务增加到此任务队列中。该任务队列是BlockiingQueue类型,也就是阻塞队列。

  • ThreadFactory:线程工厂。可以用线程工厂给每个创立出来的线程设置名字。一般情况下毋庸设置参数。

  • RejectedExecutionHandler :饱和策略,这是当任务队列中和线程池都满了时所采取的对应策略,默认是ABordPolicy,表示无法解决新任务,并抛出RejetctedExecutionException异常。此外还有3种策略,它们分别如下:

(1)CallerRunsPolicy:用调用者所在的线程来解决任务,此策略提供简单的反馈控制机制,能够减缓新任务的提交速度。
(2)DiscardPolicy:不能执行的任务,并将该任务删除。
(3)DiscardOldestPolicy:丢弃队列最近的任务,并执行当前的任务。

线程池的解决流程和原理

图1,线程池的解决流程

从上图1中可以得知线程的解决流程主要分为3个步骤:

  • 提交任务后,线程池先判断线程数能否达到核心线程数(corePoolSize)。假如未核心线程数,则创立核心线程解决任务;否则就执行下一步操作。
  • 接着线程池判断任务队列能否满了。假如没满,则将任务增加到任务队列中,否则,就执行下一步操作。
  • 接着由于任务队列满了,线程池就会判断线程数能否达到了最大线程数,假如未达到,则创立非核心线程1解决任务;否则,就执行饱和策略,默认会抛出RejectedExecutionException异常。

尽管上面详情了线程池的解决流程,但还不是很直观。我们结合下面的图2来更好的理解线程池的原理。

图2,线程池执行
从图2中可以看到,假如我们执行ThreadPoolExecutor的execute方法,会遇到各种情况:
(1)假如线程池中的线程数未达到核心线程数,则创立核心线程解决任务。
(2)假如线程数大于或者者等于核心线程数,则将任务加入任务队列,线程池中的空闲线程会不断地从任务队列中取出任务进行解决。
(3)假如任务队列满了,并且线程数没有达到最大线程数,则创立非核心线程去解决任务。
(4)假如线程数超过了最大线程数,则执行饱和策略。

ThreadPoolExecutor的基本使用

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    xmlns:app="http://schemas.android.com/apk/res-auto"    xmlns:tools="http://schemas.android.com/tools"    android:layout_width="match_parent"    android:layout_height="match_parent"    android:orientation="vertical"    tools:context=".MainActivity">        <Button        android:id="@+id/btn_start"        android:layout_width="match_parent"        android:layout_height="wrap_content"        android:text="启动" />    </LinearLayout>
package com.ju.executordemo;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.util.Log;import android.view.View;import android.widget.Button;import java.util.Random;import java.util.concurrent.Executors;import java.util.concurrent.LinkedBlockingDeque;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class MainActivity extends AppCompatActivity{    private Button btnStart;    private final int CORE_POOL_SIZE = 4;//核心线程数    private final int MAX_POOL_SIZE = 5;//最大线程数    private final long KEEP_ALIVE_TIME = 10;//空闲线程超时时间    private ThreadPoolExecutor executorPool;    private int songIndex = 0;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        initView();        //创立线程池        initExec();    }    private void initView() {        btnStart = findViewById(R.id.btn_start);        btnStart.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v) {                begin();            }        });    }    public void begin() {        songIndex++;        try {            executorPool.execute(new WorkerThread("歌曲" + songIndex));        } catch (Exception e) {            Log.e("threadtest", "AbortPolicy...已超出规定的线程数量,不能再添加了....");        }        // 所有任务已经执行完毕,我们在监听一下相关数据        new Thread(new Runnable() {            @Override            public void run() {                try {                    Thread.sleep(20 * 1000);                } catch (Exception e) {                }                sout("monitor after");            }        }).start();    }    private void sout(String msg) {        Log.i("threadtest", "monitor " + msg                + " CorePoolSize:" + executorPool.getCorePoolSize()                + " PoolSize:" + executorPool.getPoolSize()                + " MaximumPoolSize:" + executorPool.getMaximumPoolSize()                + " ActiveCount:" + executorPool.getActiveCount()                + " TaskCount:" + executorPool.getTaskCount()        );    }    private void initExec() {        executorPool = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME, TimeUnit.SECONDS,                new LinkedBlockingDeque<Runnable>(), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());    }    class WorkerThread implements Runnable {        private String threadName;        public WorkerThread (String name){            threadName = name;        }        @Override        public void run() {            boolean flag = true;            try {                while (flag){                    String tn  = Thread.currentThread().getName();                    //模拟耗时操作                    Random random = new Random();                    long time = (random.nextInt(5) + 1) * 1000;                    Thread.sleep(time);                    Log.e("threadtest","线程\"" + tn + "\"耗时了(" + time / 1000 + "秒)下载了第<" + threadName + ">");                    //下载完毕跳出循环                    flag = false;                }            }catch (Exception e){                e.printStackTrace();            }        }    }}

图3,运行结果
上述代码模拟一个下载音乐的例子来演示ThreadPoolExecutor的基本使用,启动ThreadPoolExecutor的函数是execute()方法,而后他需要一个Runnable的参数来进行启动。

ThreadPoolExecutor的其它种类

通过直接或者者间接地配置ThreadPoolExecutor的参数可以创立不同类型的ThreadPoolExecutor,其中有 4 种线程池比较常用,它们分别是 FixedThreadPool、CachedThreadPool、SingleThreadExecutor和 ScheduledThreadPool。下面分别详情这4种线程池。

  • FixedThreadPool

FixedThreadPool 是可重用固定线程数的线程池。在 Executors 类中提供了创立FixedThreadPool的方法, 如下所示:

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

FixedThreadPool的corePoolSize和maximumPoolSize都设置为创立FixedThreadPool指定的参数nThreads,也就意味着FixedThreadPool只有核心线程,并且数量是固定的,没有非核心线程。keepAliveTime设置为0L 意味着多余的线程会被立即终止。由于不会产生多余的线程,所以keepAliveTime是无效的参数。另外,任 务队列采用了无界的阻塞队列LinkedBlockingQueue。FixedThreadPool的execute方法的执行示用意如图4所 示。

图4,FixedThreadPool流程图
当执行execute()方法时,假如当前运行的线程未达到corePoolSize(核心线程数)时 就创立核心线程来解决任务,假如达到了核心线程数则将任务增加到LinkedBlockingQueue中。 FixedThreadPool就是一个有固定数量核心线程的线程池,并且这些核心线程不会被回收。当线程数超过corePoolSize时,就将任务存储在任务队列中;当线程池有空闲线程时,则从任务队列中去取任务执行

  • CachedThreadPool

CachedThreadPool是一个根据需要创立线程的线程池,创立CachedThreadPool的代码如下所示:

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

CachedThreadPool的corePoolSize为0,maximumPoolSize设置为Integer.MAX_VALUE,这意味着 CachedThreadPool没有核心线程,非核心线程是无界的。keepAliveTime设置为60L,则空闲线程等待新任务 的最长时间为 60s。在此用了阻塞队列 SynchronousQueue,它是一个不存储元素的阻塞队列,每个插入操作 必需等待另一个线程的移除操作,同样任何一个移除操作都等待另一个线程的插入操作。CachedThreadPool 的execute方法的执行示用意如图5所示。

图5,CachedThreadPool流程图
当执行execute()方法时,首先会执行SynchronousQueue的offer()方法来提交任务,并且查询线程池中能否有空闲的线程执行SynchronousQueue的poll()方法来移除任务。假如有则配对成功,将任务交给这个空闲的线程解决;假如没有则配对失败,创立新的线程去解决任务。当线程池中的线程空闲时,它会执行 SynchronousQueue的poll()方法,等待SynchronousQueue中新提交的任务。假如超过 60s 没有新任务提交到 SynchronousQueue,则这个空闲线程将终止。由于maximumPoolSize 是无界的,所以假如提交的任务大于线 程池中线程解决任务的速度就会不断地创立新线程。另外,每次提交任务都会立即有线程去解决。所以,CachedThreadPool比较适于大量的需要立即解决并且耗时较少的任务。

  • SingleThreadExecutor

SingleThreadExecutor是使用单个工作线程的线程池,其创立源码如下所示:

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

corePoolSize和maximumPoolSize都为1,意味着SingleThreadExecutor只有一个核心线程,其余的参数都 和FixedThreadPool一样,这里就不赘述了。SingleThreadExecutor的execute()方法的执行示用意如图5所示。

图5,SingleThreadExecutor流程图
当执行execute()方法时,假如当前运行的线程数未达到核心线程数,也就是当前没有运行的线程,则创立一个新线程来解决任务。假如当前有运行的线程,则将任务增加到阻塞队列LinkedBlockingQueue中。因而,SingleThreadExecutor能确保所有的任务在一个线程中按照顺序逐一执行。

  • ScheduledThreadPool

ScheduledThreadPool是一个能实现定时和周期性任务的线程池,它的创立源码如下所示:

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

这里创立了ScheduledThreadPoolExecutor,ScheduledThreadPoolExecutor继承自ThreadPoolExecutor,它主要用于给定延时之后的运行任务或者者定期解决任务。ScheduledThreadPoolExecutor 的构造方法如下所示:

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

从上面的代码可以看出,ScheduledThreadPoolExecutor 的构造方法最终调用的是ThreadPoolExecutor的 构造方法。corePoolSize是传进来的固定数值,maximumPoolSize的值是Integer.MAX_VALUE。由于采用的 DelayedWorkQueue是无界的,所以maximumPoolSize这个参数是无效的。ScheduledThreadPoolExecutor的 execute方法的执行示用意如图6所示。

图6,ScheduledThreadPoolExecutor流程图
当执行ScheduledThreadPoolExecutor的scheduleAtFixedRate()或者者scheduleWithFixedDelay()方法时,会向DelayedWorkQueue增加一个 实现RunnableScheduledFuture接口的ScheduledFutureTask(任务的包装类),并会检查运行的线程能否达到corePoolSize。假如没有则新建线程并启动它,但并不是立即去执行任务,而是去DelayedWorkQueue中取ScheduledFutureTask,而后去执行任务。假如运行的线程达到了corePoolSize时,则将任务增加到DelayedWorkQueue中。DelayedWorkQueue会将任务进行排序,先要执行的任务放在队列的前面。其跟此前详情的线程池不同的是,当执行完任务后,会将ScheduledFutureTask中time变量改为下次要执行的时间并放回到DelayedWorkQueue中。

参考

  • [刘望舒]Android进阶之光
  • Android线程池(一)简单使用
说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » Android日记之线程池

发表回复