Android多线程的四种方式：Handler、AsyncTask、ThreadPoolExector、IntentService

     异步通信机制，将工作线程中需更新UI的 *** 作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理。Handler不仅仅能将子线程的数据传递给主线程，它能实现任意两个线程的数据传递。

（1）Message

    Message 可以在线程之间传递消息。可以在它的内部携带少量数据，用于在不同线程之间进行数据交换。除了 what 字段，还可以使用 arg1 和 arg2 来携带整型数据，使用 obj 来携带 Object 数据。

（2） Handler

    Handler 作为处理中心，用于发送（sendMessage 系列方法）与处理消息（handleMessage 方法）。

（3） MessageQueue

    MessageQueue 用于存放所有通过 Handler 发送的消息。这部分消息会一直存放在消息队列中，直到被处理。每个线程中只会有一个 MessageQueue 对象

（4） Looper

    Looper 用于管理 MessageQueue 队列，Looper对象通过loop()方法开启了一个死循环——for (;;)｛｝，不断地从looper内的MessageQueue中取出Message，并传递到 Handler 的 handleMessage() 方法中。每个线程中只会有一个 Looper 对象。

    AsyncTask 是一种轻量级的任务异步类，可以在后台子线程执行任务，且将执行进度及执行结果传递给 UI 线程。

（1）onPreExecute()

    在 UI 线程上工作，在任务执行 doInBackground() 之前调用。此步骤通常用于设置任务，例如在用户界面中显示进度条。

（2）doInBackground(Params params)

    在子线程中工作，在 onPreExecute() 方法结束后执行，这一步被用于在后台执行长时间的任务，Params 参数通过 execute(Params) 方法被传递到此方法中。任务执行结束后，将结果传递给 onPostExecute(Result) 方法，同时我们可以通过 publishProgress(Progress) 方法，将执行进度发送给 onProgressUpdate(Progress) 方法。

（3）onProgressUpdate(Progress values)

    在 UI 线程上工作，会在 doInBackground() 中调用 publishProgress(Progress) 方法后执行，此方法用于在后台计算仍在执行时(也就是 doInBackgound() 还在执行时)将计算执行进度通过 UI 显示出来。例如，可以通过动画进度条或显示文本字段中的日志，从而方便用户知道后台任务执行的进度。

（4）onPostExecute(Result result)

    在 UI 线程上工作，在任务执行完毕（即 doInBackground(Result) 执行完毕）并将执行结果传过来的时候工作。

使用规则：

（1）AsyncTask 是个抽象类，所以要创建它的子类实现抽象方法

（1）AsyncTask 类必须是在 UI 线程中被加载，但在Android 41（API 16）开始，就能被自动加载完成。

（2）AsyncTask 类的实例对象必须在 UI 线程中被创建。

（3）execute() 方法必须是在 UI 线程中被调用。

（4）不要手动调用方法 onPreExecute()、onPostExecute()、doInBackground()、onProgressUpdate()

（5）任务只能执行一次(如果尝试第二次执行，将抛出异常)。即一个AsyncTask对象只能调用一次execute()方法。

原理：

          其源码中原理还是 Thread 与 Handler 的实现，其包含 两个线程池，一个 Handler，如下所示：

名称类型作用

SERIAL_EXECUTOR线程池分发任务，串行分发，一次只分发一个任务

THREAD_POOL_EXECUTOR线程池执行任务，并行执行，执行的任务由 SERIAL_EXECUTOR 分发

InternalHandlerHandler负责子线程与主线程的沟通，通知主线程做 UI 工作

    一方面减少了每个并行任务独自建立线程的开销，另一方面可以管理多个并发线程的公共资源，从而提高了多线程的效率。所以ThreadPoolExecutor比较适合一组任务的执行。Executors利用工厂模式对ThreadPoolExecutor进行了封装。

Executors提供了四种创建ExecutorService的方法，他们的使用场景如下：

1 ExecutorsnewFixedThreadPool()

    创建一个定长的线程池，每提交一个任务就创建一个线程，直到达到池的最大长度，这时线程池会保持长度不再变化。

当线程处于空闲状态时，它们并不会被回收，除非线程池被关闭。当所有的线程都处于活动状态时，新任务都会处于等待状态，直到有线程空闲出来。

只有核心线程并且不会被回收，能够更加快速的响应外界的请求。

2 ExecutorsnewCachedThreadPool()

    创建一个可缓存的线程池，如果当前线程池的长度超过了处理的需要时，它可以灵活的回收空闲的线程，当需要增加时，它可以灵活的添加新的线程，而不会对池的长度作任何限制

    线程数量不定的线程池，只有非核心线程，最大线程数为 IntegerMAX_VALUE。当线程池中的线程都处于活动状态时，线程池会创建新的线程来处理新任务，否则利用空闲的线程来处理新任务。线程池中的空闲线程具有超时机制，为 60s。

    任务队列相当于一个空集合，导致任何任务都会立即被执行，适合执行大量耗时较少的任务。当整个线程池都处于限制状态时，线程池中的线程都会超时而被停止。

3 ExecutorsnewScheduledThreadPool()

    创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。

    非核心线程数没有限制，并且非核心线程闲置的时候立即回收，主要用于执行定时任务和具有固定周期的重复任务。

4 ExecutorsnewSingleThreadExecutor()

    创建一个单线程化的executor，它只创建唯一的worker线程来执行任务

    只有一个核心线程，保证所有的任务都在一个线程中顺序执行，意义在于不需要处理线程同步的问题。

    一般用于执行后台耗时任务，当任务执行完成会自动停止；同时由于它是一个服务，优先级要远远高于线程，更不容易被系统杀死，因此比较适合执行一些高优先级的后台任务。

使用步骤：创建IntentService的子类，重写onHandleIntent方法，在onHandleIntent中执行耗时任务

    原理：在源码实现上，IntentService封装了HandlerThread和Handler。onHandleIntent方法结束后会调用IntentService的stopSelf(int startId)方法尝试停止服务。

    IntentService的内部是通过消息的方式请求HandlerThread执行任务，HandlerThread内部又是一种使用Handler的Thread，这就意味着IntentService和Looper一样是顺序执行后台任务的

（HandlerThread：封装了Handler + ThreadHandlerThread适合在有需要一个工作线程（非UI线程）+任务的等待队列的形式，优点是不会有堵塞，减少了对性能的消耗，缺点是不能同时进行多个任务的处理，需要等待进行处理。处理效率低，可以当成一个轻量级的线程池来用）

       传统的多线程是通过继承Thread类及实现Runnable接口来实现的，每次创建及销毁线程都会消耗资源、响应速度慢，且线程缺乏统一管理，容易出现阻塞的情况，针对以上缺点，线程池就出现了。

       线程池是一个创建使用线程并能保存使用过的线程以达到复用的对象，简单的说就是一块缓存了一定数量线程的区域。

       1复用线程：线程执行完不会立刻退出，继续执行其他线程；

       2管理线程：统一分配、管理、控制最大并发数；

       1降低因频繁创建&销毁线程带来的性能开销，复用缓存在线程池中的线程；

       2提高线程执行效率&响应速度，复用线程：响应速度；管理线程：优化线程执行顺序，避免大量线程抢占资源导致阻塞现象；

       3提高对线程的管理度；

       线程池的使用也比较简单，流程如下：

       接下来通过源码来介绍一下ThreadPoolExecutor内部实现及工作原理。

       线程池的最终实现类是ThreadPoolExecutor，通过实现可以一步一步的看到，父接口为Executor:

       其他的继承及实现关系就不一一列举了，直接通过以下图来看一下：

       从构造方法开始看：

       通过以上可以看到，在创建ThreadPoolExecutor时，对传入的参数是有要求的：corePoolSize不能小于0；maximumPoolSize需要大于0，且需要大于等于corePoolSize；keepAliveTime大于0；workQueue、threadFactory都不能为null。

       在创建完后就需要执行Runnable了，看以下execute()方法：

       在execute()内部主要执行的逻辑如下：

       分析点1：如果当前线程数未超过核心线程数，则将runnable作为参数执行addWorker()，true表示核心线程，false表示非核心线程；

       分析点2：核心线程满了，如果线程池处于运行状态则往workQueue队列中添加任务，接下来判断是否需要拒绝或者执行addWorker()；

       分析点3：以上都不满足时 [corePoolSize=0且没有运行的线程，或workQueue已经满了] ，执行addWorker()添加runnable，失败则执行拒绝策略；

        总结一下：线程池对线程创建的管理，流程图如下：

       在执行addWorker时，主要做了以下两件事：

       分析点1：将runnable作为参数创建Worker对象w，然后获取w内部的变量thread；

       分析点2：调用start()来启动thread；

       在addWorker()内部会将runnable作为参数传给Worker，然后从Worker内部读取变量thread，看一下Worker类的实现：

       Worker实现了Runnable接口，在Worker内部，进行了赋值及创建 *** 作，先将execute()时传入的runnable赋值给内部变量firstTask，然后通过ThreadFactorynewThread(this)创建Thread，上面讲到在addWorker内部执行tstart()后，会执行到Worker内部的run()方法，接着会执行runWorker(this)，一起看一下：

       前面可以看到，runWorker是执行在子线程内部，主要执行了三件事：

       分析1：获取当前线程，当执行shutdown()时需要将线程interrupt()，接下来从Worker内部取到firstTask，即execute传入的runnable，接下来会执行；

       分析2：while循环，task不空直接执行；否则执行getTask()去获取，不为空直接执行；

       分析3：对有效的task执行run()，由于是在子线程中执行，因此直接run()即可，不需要start()；

       前面看到，在while内部有执行getTask()，一起看一下：

       getTask()是从workQueue内部获取接下来需要执行的runnable，内部主要做了两件事：

       分析1：先获取到当前正在执行工作的线程数量wc，通过判断allowCoreThreadTimeOut[在创建ThreadPoolExecutor时可以进行设置]及wc > corePoolSize来确定timed值；

       分析2：通过timed值来决定执行poll()或者take()，如果WorkQueue中有未执行的线程时，两者作用是相同的，立刻返回线程；如果WorkQueue中没有线程时，poll()有超时返回，take()会一直阻塞；如果allowCoreThreadTimeOut为true，则核心线程在超时时间没有使用的话，是需要退出的；wc > corePoolSize时，非核心线程在超时时间没有使用的话，是需要退出的；

       allowCoreThreadTimeOut是可以通过以下方式进行设置的：

       如果没有进行设置，那么corePoolSize数量的核心线程会一直存在。

        总结一下：ThreadPoolExecutor内部的核心线程如何确保一直存在，不退出？

       上面分析已经回答了这个问题，每个线程在执行时会执行runWorker()，而在runWorker()内部有while()循环会判断getTask()，在getTask()内部会对当前执行的线程数量及allowCoreThreadTimeOut进行实时判断，如果工作数量大于corePoolSize且workQueue中没有未执行的线程时，会执行poll()超时退出；如果工作数量不大于corePoolSize且workQueue中没有未执行的线程时，会执行take()进行阻塞，确保有corePoolSize数量的线程阻塞在runWorker()内部的while()循环不退出。

       如果需要关闭线程池，需要如何 *** 作呢，看一下shutdown()方法：

       以上可以看到，关闭线程池的原理：a 遍历线程池中的所有工作线程；b 逐个调用线程的interrupt()中断线程（注：无法响应中断的任务可能永远无法终止）

       也可调用shutdownNow()来关闭线程池，二者区别：

       shutdown()：设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程；

       shutdownNow()：设置线程池的状态为STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表；

       使用建议：一般调用shutdown()关闭线程池；若任务不一定要执行完，则调用shutdownNow()；

        总结一下：ThreadPoolExecutor在执行execute()及shutdown()时的调用关系，流程图如下：

       线程池可以通过Executors来进行不同类型的创建，具体分为四种不同的类型，如下：

       可缓存线程池：不固定线程数量，且支持最大为IntegerMAX_VALUE的线程数量：

       1、线程数无限制

       2、有空闲线程则复用空闲线程，若无空闲线程则新建线程

       3、一定程度上减少频繁创建/销毁线程，减少系统开销

       固定线程数量的线程池：定长线程池

       1、可控制线程最大并发数(同时执行的线程数)

       2、超出的线程会在队列中等待。

       单线程化的线程池：可以理解为线程数量为1的FixedThreadPool

       1、有且仅有一个工作线程执行任务

       2、所有任务按照指定顺序执行，即遵循队列的入队出队规则

       定时以指定周期循环执行任务

       一般来说，等待队列 BlockingQueue 有: ArrayBlockingQueue 、 LinkedBlockingQueue 与 SynchronousQueue 。

       假设向线程池提交任务时，核心线程都被占用的情况下:

        ArrayBlockingQueue ：基于数组的阻塞队列，初始化需要指定固定大小。

       当使用此队列时，向线程池提交任务，会首先加入到等待队列中，当等待队列满了之后，再次提交任务，尝试加入队列就会失败，这时就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。所以最终可能出现后提交的任务先执行，而先提交的任务一直在等待。

        LinkedBlockingQueue ：基于链表实现的阻塞队列，初始化可以指定大小，也可以不指定。

       当指定大小后，行为就和 ArrayBlockingQueue一致。而如果未指定大小，则会使用默认的 IntegerMAX_VALUE 作为队列大小。这时候就会出现线程池的最大线程数参数无用，因为无论如何，向线程池提交任务加入等待队列都会成功。最终意味着所有任务都是在核心线程执行。如果核心线程一直被占，那就一直等待。

        SynchronousQueue ：无容量的队列。

       使用此队列意味着希望获得最大并发量。因为无论如何，向线程池提交任务，往队列提交任务都会失败。而失败后如果没有空闲的非核心线程，就会检查如果当前线程池中的线程数未达到最大线程，则会新建线程执行新提交的任务。完全没有任何等待，唯一制约它的就是最大线程数的个数。因此一般配合IntegerMAX_VALUE就实现了真正的无等待。

       但是需要注意的是， 进程的内存是存在限制的，而每一个线程都需要分配一定的内存。所以线程并不能无限个。

一般我们想要执行耗时 *** 作都会想开启Thread子线程去处理，但是多次创建和销毁线程是很耗系统资源的。为了解决这一问题，我们可以自己构建一个循环线程，在线程当中创建一个Looper轮循器，来进行消息的轮循， 当有耗时任务需要投放到该循环线程时，线程就会执行耗时任务，任务执行完成之后，线程又会处于阻塞等待状态，不会马上销毁掉，直到下一个耗时任务被投放进来；即通过阻塞和等待来保证性能最优，为此Google为我们封装好了HandlerThread框架。

HandlerThread本质上就是一个Thread子线程，不同的是在Thread内部有一个Looper开启了轮循器；

HandlerThread = Handler + Thread + Looper

由于一般的Thread没有开启Looper轮循器，所以不能在子线程中创建handler，因为没有对应的MessageQueue与handler相关联，而MessageQueue是由Looper进行维护的；如果想在子线程中创建handler，必须先通过Looperprepare()创建一个Looper，再通过Looperloop()开启循环，才能使用Handler。

1、HandlerThread本质上是一个线程类，继承了Thread；

2、HandlerThread有自己的内部Looper对象，可以进行loop循环；所以在HandlerThread中可以创建handler来发送和处理消息；

3、通过获取HandlerThread的Looper对象传递给Handler，可以在handleMessage()中执行异步 *** 作；

4、handler中的looper默认绑定了UI线程的MessageQueue，对于非UI线程想使用MessageQueue机制的，HandlerThread的内部Looper最适合，它不会干扰和阻塞UI线程，减少了对性能的消耗，但是处理效率低；

5、HandlerThread是一个串行队列，会比较稳定；

以上就是关于Android多线程的四种方式：Handler、AsyncTask、ThreadPoolExector、IntentService全部的内容，包括:Android多线程的四种方式：Handler、AsyncTask、ThreadPoolExector、IntentService、Android线程池ThreadPoolExecutor详解、Android中的特殊线程——HandlerThread等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！