Android基础之线程

多线程开发在android开发中非常常见，多线程相关问题也是开发人员面试的必考题，那么今天我们就来聊聊Android中的多线程。
本文的要点如下：

  • 线程概述
  • Java中的线程
  • Android中的线程
    • AsyncTask
    • HandlerThread
    • IntentService
  • 线程池
    • 线程池的优势
    • 线程池的用法
    • 线程池使用实例
    • 4种常见的线程池
  • 总结

线程概述

线程是CPU调度的最小单元。同时线程也是一种受限的系统资源。即线程不可无限制的产生且线程的创建和销毁都有一定的开销。

那么，如何避免频繁创建和销毁线程所带来的系统开销？
这就要用到线程池了，线程池中会缓存一定数量的线程，进而通过复用以及管理线程提高系统的稳定性。

Android中的线程分为两类：

主线程：用于处理界面交互相关的逻辑，一般一个应用只有一个。
子线程：除主线程之外都是子线程，主要用于执行耗时操作，防止主线程阻塞造成ANR。

Java中的线程

详见：Java基础之线程

Android中线程形态

除了Java本身的线程类，Android中还封装了多种异步类，便于Android中多线程的开发。

AsyncTask

AsyncTask是一个Android已经封装好的轻量级异步类，AsyncTask本身是抽象类，即使用时需继承实现子类。相信大家在平时的开发中应该多多少少都用过，AsyncTask本身封装的非常简洁，使用起来也非常方便。

AsyncTask是一个抽象泛型类。
public abstract class AsyncTask<Params, Progress, Result>
其中，三个泛型类型参数的含义如下：
Params：开始异步任务执行时传入的参数类型；
Progress：异步任务执行过程中，返回下载进度值的类型；
Result：异步任务执行完成后，返回的结果类型。
如果AsyncTask确定不需要传递具体参数，那么这三个泛型参数可以用Void来代替。

AsyncTask子类的实现：

public class MyTask extends AsyncTask<String, Integer, Integer>  {

    //执行线程任务前的操作,可以用于初始化参数
    @Override
    protected void onPreExecute() {
        super.onPreExecute();

    }

    //在子线程中运行，用于处理耗时任务
    //这里随便写了个更新进度的逻辑
    @Override
    protected Integer doInBackground(String... strings) {
        //每0.1秒更新一次进度，直到100
        for(int i = 0;i<100;i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            publishProgress(i);
        }
        return null;
    }

  //主线程中进行，利用参数中的数值就可以对界面元素进行相应的更新，
    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
    }

    //可以利用返回的数据来进行一些UI操作，在主线程中进行
    @Override
    protected void onPostExecute(Integer integer) {
        super.onPostExecute(integer);
    }

    
}

以上四个方法即为AsyncTask的核心方法。

onPreExecute()：这个方法会在后台任务开始执行之前调用，在主线程执行。可以用于初始化参数或进行一些界面上的初始化工作，比如显示一个进度条对话框等。

doInBackground(String... strings)：这个方法中的所有代码都会在子线程中运行，这里就是我们执行耗时任务的地方。
任务一旦完成就可以通过return语句来将任务的执行结果进行返回，如果AsyncTask的第三个泛型参数指定的是Void，就可以不返回任务执行结果。由于是在子线程中，因此这个方法中是不可以进行UI操作的。

onProgressUpdate(Integer... values) ：在这个方法中可以对UI进行操作，在主线程中进行，当在doInBackground()方法中调用了publishProgress(Integer... values)方法后，这个方法就很快会被调用，方法中携带的参数就是在后台任务中传递过来的，利用参数中的数值就可以对界面元素进行相应的更新。

onPostExecute(Integer integer)：doInBackground()方法执行完毕并通过return语句进行返回时，这个方法就很快会被调用。return返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，在主线程中进行，比如展示任务执行的结果。

上面几个方法的调用顺序：onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()。
如果不需要更新进度信息则为：onPreExecute() --> doInBackground() --> onPostExecute()。

另外除了上面四个方法，AsyncTask还提供了onCancelled()方法，它同样在主线程中执行，用AsyncTask中的cancel()方法取消任务时，onCancelled()会被调用，这个时候onPostExecute()不会被调用，但是要注意的是，AsyncTask中的cancel()方法并不是真正去取消任务，只是设置这个任务为取消状态，我们需要在doInBackground()判断终止任务。就好比想要终止一个线程，调用interrupt()方法，只是进行标记为中断，需要在线程内部进行标记判断然后中断线程。

HandlerThread

HandlerThread也是一个Android已封装好的轻量级异步类。从名字上也不难推断出，实际上，HandlerThread本质上是通过继承Thread类和封装Handler类的使用，从而使得创建新线程和与其他线程进行通信变得更加方便易用。HandlerThread主要是用来执行多个耗时操作，而不需要多次开启线程。

通过继承Thread类，快速地创建1个带有Looper对象的新工作线程；
通过封装Handler类，快速创建Handler与其他线程进行通信。

HandlerThread的使用方法如下：

        //1.创建HandlerThread的实例对象，传入的参数为线程的名字
        HandlerThread mhandlerThread = new HandlerThread("MyHandlerThread");
        //2.启动HandlerThread线程
        mhandlerThread.start();
        //3.将HandlerThread与Handler绑定在一起
        Handler workHandler = new Handler(mhandlerThread.getLooper()){
            @Override
            public void handleMessage(Message msg) {
                //这里会在子线程中执行
                super.handleMessage(msg);
            }
        };

发送message的方法和普通的Handler没什么区别：

        workHandler.sendMessage(msg);

结束线程用mHandlerThread.quit()方法，会停止线程的消息循环。

IntentService

Android里的一个封装类，继承四大组件之一的Service。
详见：Android基础之Service

线程池

在开发中，我们往往会通过new Thread来开启一个子线程，待子线程操作完成以后通过Handler切换到主线程中运行。这么以来我们无法管理我们所创建的子线程，并且无限制的创建子线程，它们相互之间竞争，很有可能由于占用过多资源而导致死机或者OOM。因此Java中为我们提供了线程池来管理我们所创建的线程。

线程池的优势：

  1. 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；
  2. 提高系统响应速度，当有任务到达时，无需等待新线程的创建便能立即执行；
  3. 方便线程并发数的管控，线程若是无限制的创建，不仅会额外消耗大量系统资源，更是占用过多资源而阻塞系统或oom等状况，从而降低系统的稳定性。线程池能有效管控线程，统一分配、调优，提供资源使用率；
  4. 更强大的功能，线程池提供了定时、定期以及可控线程数等功能的线程池，使用方便简单。

线程池的使用方法

其实使用线程池大致可以分为3步：

  1. 实例化线程池
  2. 添加任务
  3. 关闭线程池

实例化线程池

线程池的构造方法如下：

    public ThreadPoolExecutor(int corePoolSize,
              int maximumPoolSize,
              long keepAliveTime,
              TimeUnit unit,
              BlockingQueue<Runnable> workQueue,
              ThreadFactory threadFactory,
              RejectedExecutionHandler handler)

corePoolSize：线程池中的核心线程数，默认情况下，核心线程一直存活在线程池中，即便他们在线程池中处于闲置状态。除非我们将ThreadPoolExecutor的allowCoreThreadTimeOut属性设为true的时候，这时候处于闲置的核心线程在等待新任务到来时会有超时策略，这个超时时间由keepAliveTime来指定。一旦超过所设置的超时时间，闲置的核心线程就会被终止。
maximumPoolSize：线程池中所容纳的最大线程数，如果活动的线程达到这个数值以后，后续的新任务将会被阻塞。包含核心线程数+非核心线程数。
keepAliveTime：非核心线程闲置时的超时时长，对于非核心线程，闲置时间超过这个时间就会被回收。当allowCoreThreadTimeOut属性设为true的时候，这个时间同样对核心线程产生有效。
unit：用于指定keepAliveTime参数的时间单位。是一个枚举对象
workQueue：线程池中保存等待执行的任务的阻塞队列。通过线程池中的execute方法提交的Runable对象都会存储在该队列中。

队列 特点
ArrayBlockingQueue 基于数组实现的有界的阻塞队列,该队列按照FIFO（先进先出）原则对队列中的元素进行排序。
LinkedBlockingQueue 基于链表实现的阻塞队列，该队列按照FIFO（先进先出）原则对队列中的元素进行排序。
SynchronousQueue 内部没有任何容量的阻塞队列。在它内部没有任何的缓存空间。对于SynchronousQueue中的数据元素只有当我们试着取走的时候才可能存在。
PriorityBlockingQueue 具有优先级的无限阻塞队列。
实现BlockingQueue接口 自定义阻塞队列。

threadFactory：线程工厂，为线程池提供新线程的创建。ThreadFactory是一个接口，里面只有一个newThread方法。 默认为DefaultThreadFactory类。
handler：实现RejectedExecutionHandler接口的对象，接口里面只有一个rejectedExecution方法。当任务队列已满并且线程池中的活动线程已经达到所限定的最大值或者是无法成功执行任务，这时候ThreadPoolExecutor会调用RejectedExecutionHandler中的rejectedExecution方法。在ThreadPoolExecutor中有四个内部类实现了RejectedExecutionHandler接口。在线程池中它默认是AbortPolicy，在无法处理新任务时抛出RejectedExecutionException异常。

添加任务

构造完ThreadPoolExecutor对象之后，就可以向线程池中添加任务了。
添加任务有两种方法：execute和submit；

最简单的就是execute()方法，只需要实现一个Runnable接口就行。但是当我们使用execute来提交任务时，由于execute方法没有返回值，所以说我们也就无法判定任务是否被线程池执行成功。

submit()方法稍微复杂些，当我们使用submit来提交任务时,它会返回一个future，我们就可以通过这个future来判断任务是否执行成功，还可以通过future的get方法来获取返回值。如果子线程任务没有完成，get方法会阻塞住直到任务完成，而使用get(long timeout, TimeUnit unit)方法则会阻塞一段时间后立即返回，这时候有可能任务并没有执行完。我们可以用future.isDone()方法来判断任务是否执行完毕，之后再取返回值。

        //Future<?> submit(Runnable task)
        Future<?> future = threadpool.submit(new Runnable() {
            
            @Override
            public void run() {
                System.out.println("子线程id ：" + Thread.currentThread().getId());//输出当前线程id
                
            }
        });
        //Future<T> submit(Callable<T> task)
        Future<Integer> future2 = threadpool.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception{
                Thread.sleep(3000);
                System.out.println("子线程id ：" + Thread.currentThread().getId());//输出当前线程id
                System.out.println("future2 任务结束");
                return 315;
            }
        });

关闭线程池

可以调用线程池的shutdown()或shutdownNow()方法来关闭线程池
shutdown原理：将线程池状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。
shutdownNow原理：将线程池的状态设置成STOP状态，然后中断所有任务(包括正在执行的)的线程，并返回等待执行任务的列表。
一般情况下建议调用shutdown()关闭线程池；若任务不一定要执行完，则调用shutdownNow()。

线程池的使用实例：

                //打印主线程id
        System.out.println("主线程id ： " + Thread.currentThread().getId());//输出主线程id
        //实例化线程池
        ExecutorService threadpool = new ThreadPoolExecutor(5, 10, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        //构建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程id ：" + Thread.currentThread().getId());//输出当前线程id
            }
        };
        //提交任务
        //方式1,execute
        threadpool.execute(task);
        //方式2,submit
                //Runnable任务
        Future<?> future = threadpool.submit(task);
                //Callable任务
        Future<Integer> future2 = threadpool.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception{
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getId());//输出当前线程id
                System.out.println("future2 任务结束");
                return 315;
            }
        });

        while(!future2.isDone()) {
            System.out.println("任务future2还未执行完毕");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("任务future2执行完毕");
        try {
                        //获取返回值
            System.out.println("任务返回值为" + future2.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
        //关闭线程池
        threadpool.shutdown();

以上代码的执行结果为：

主线程id ： 1
子线程id ：11
子线程id ：12
任务future2还未执行完毕
任务future2还未执行完毕
任务future2还未执行完毕
13
future2 任务结束
任务future2执行完毕
任务返回值为315

4种常见的线程池

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

  1. 定长线程池（FixedThreadPool）
  2. 定时线程池（ScheduledThreadPool ）
  3. 可缓存线程池（CachedThreadPool）
  4. 单线程化线程池（SingleThreadExecutor）

他们都是直接或者间接配置ThreadPoolExecutor来实现他们各自的功能。这四种线程池可以通过Executors类获取。

FixedThreadPool

定长线程池只有核心线程，线程数量固定，任务队列无大小限制（超出的线程任务会在队列中等待）。通过 Executors.newFixedThreadPool() 创建。

        //实例化定长线程池，参数为核心线程数量
        ExecutorService myFixedThreadPool = Executors.newFixedThreadPool(5);//设置线程数量固定为5
        //构建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程id ：" + Thread.currentThread().getId());//输出当前线程id
            }
        };
        //提交任务
        myFixedThreadPool.execute(task);
        //关闭线程池
        myFixedThreadPool.shutdown();

newFixedThreadPool只有核心线程，并且这些线程都不会被回收，因此它能够更快速的响应外界请求。

ScheduledThreadPool

定时线程池核心线程数量固定、非核心线程数量无限制（闲置时会马上回收），通过Executors.newScheduledThreadPool()创建。

        //实例化定时线程池，参数为核心线程数量
        ScheduledExecutorService myScheduledThreadPool = Executors.newScheduledThreadPool(5);//核心线程数为5
        //构建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程id ：" + Thread.currentThread().getId());//输出当前线程id
            }
        };
        //用schedule提交任务，参数为任务，延迟时间，时间单位
        //eg: 延迟1s后执行
        myScheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS);
         //用scheduleAtFixedRate提交任务，参数为任务，延迟时间，间隔时间，时间单位
        //eg:延迟10ms后、每隔1000ms执行一次任务
        myScheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);

        //关闭线程池
        myScheduledThreadPool.shutdown();

ScheduledThreadPool执行任务使用的是如下方法：

  1. schedule(Runnable command, long delay, TimeUnit unit)：延迟一定时间后执行Runnable任务；
  2. schedule(Callable callable, long delay, TimeUnit unit)：延迟一定时间后执行Callable任务；
  3. scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)：延迟一定时间后，以间隔period时间的频率周期性地执行任务；
  4. scheduleWithFixedDelay(Runnable command, long initialDelay, long delay,TimeUnit unit):与scheduleAtFixedRate()方法很类似，但是不同的是scheduleWithFixedDelay()方法的周期时间间隔是以上一个任务执行结束到下一个任务开始执行的间隔，而scheduleAtFixedRate()方法的周期时间间隔是以上一个任务开始执行到下一个任务开始执行的间隔，也就是说scheduleWithFixedDelay方法执行的任务的开始时间其实是不可预知的，和前一个任务的执行时间有关，而scheduleAtFixedRate方法执行任务的触发时间都是可预知的，是固定的。

CachedThreadPool

可缓存线程池的核心线程数为0， 线程池的最大线程数Integer.MAX_VALUE，具备超时机制，当线程处于闲置状态超过60秒的时候便会被回收，当线程池中的线程都处于活动状态的时候，线程池就会创建一个新的线程来处理任务。若是整个线程池的线程都处于闲置状态超过60秒以后，线程池中是不存在任何线程的，所以这时候它几乎不占用任何的系统资源。

        //实例化定时线程池
        ExecutorService myCachedThreadPool = Executors.newCachedThreadPool();
        //构建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程id ：" + Thread.currentThread().getId());//输出当前线程id
            }
        };
        //提交任务
        myCachedThreadPool.execute(task);
        //关闭线程池
        myCachedThreadPool.shutdown();

使用方法很简单，无需配置参数，可以直接添加任务。

SingleThreadExecutor

单线程化线程池，在这个线程池中只有一个核心线程，对于任务队列没有大小限制，也就意味着一个任务处于活动状态时，其他任务都会在任务队列中排队等候依次执行，因此不需要处理线程同步的问题。

        ExecutorService mySingleThreadExecutor = Executors.newSingleThreadExecutor();
//构建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("子线程id ：" + Thread.currentThread().getId());//输出当前线程id
            }
        };
        //提交任务
        mySingleThreadExecutor.execute(task);
        //关闭线程池
        mySingleThreadExecutor.shutdown();

单线程化线程池不适合并发但可能引起IO阻塞性及影响UI线程响应的操作，如数据库操作，文件操作等。

总结

线程的目的都是执行功能，主要实现的也就是Runnable和Callable两个接口，基本的使用还是不难的，但是要想理解原理，还需要更深入的去学习源码。有关线程的内容有很多，本次只是进行了大致的总结，之后有时间会进行更加详细的总结。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,607评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,047评论 2赞 379
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,496评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,405评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,400评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,479评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,883评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,535评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,743评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,544评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,612评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,309评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,881评论 3赞 306
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,891评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,136评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,783评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,316评论 2赞 342