189 8069 5689
你是要怎么个意思？
创新互联公司致力于成都网站建设、成都网站设计,成都网站设计,集团网站建设等服务标准化，推过标准化降低中小企业的建站的成本，并持续提升建站的定制化服务水平进行质量交付，让企业网站从市场竞争中脱颖而出。 选择创新互联公司，就选择了安全、稳定、美观的网站建设服务！
创建子线程即就是在你的程序体（也就是MainThread）中创建子线程：
1、匿名内部类对Thread类进行覆写：new
Thread()｛
覆写run方法
｝.start();
2、或者
new
Thread(new
Runnable(){········}).start();套用两层匿名内部类也可以
3、再或者就是将当前类继承Runnable然后在当前类里覆写上run方法，最后在需要开线程的地方写上new
Thread(this).start();
####别忘了在更新UI的时候跳回主线程就行了，用runOnUiThread
和handle机制都可以####
1 AsyncTask（或者Thread）+Handler
启动子线程，子线程执行完任务后，通过Handler给主线程中的Looper发送消息
2 Activity.runOnUiThread(Runnable r)
在Activity中启动子线程，子线程执行完成任务后，调用runOnUiThread(Runnable r)。runOnUiThread(Runnable r)是Activity中的方法，方法里会判断当前线程是否是UI线程，如果是，run()方法在UI线程执行，如果不是，通过mHandler把Runnable发送到主线程的Looper中，Looper取出消息再分发给mHandler，mHandler收到消息后，回调run()方法。mHandler是Activity中一个final修饰的成员，所有的Activity对象共用这一个handler对象。
Android 中线程可分为 主线程 和 子线程 两类，其中主线程也就是 UI线程 ，它的主要这作用就是运行四大组件、处理界面交互。子线程则主要是处理耗时任务，也是我们要重点分析的。
首先 Java 中的各种线程在 Android 里是通用的，Android 特有的线程形态也是基于 Java 的实现的，所以有必要先简单的了解下 Java 中的线程，本文主要包括以下内容：
在 Java 中要创建子线程可以直接继承 Thread 类，重写 run() 方法：
或者实现 Runnable 接口，然后用Thread执行Runnable，这种方式比较常用：
简单的总结下：
Callable 和 Runnable 类似，都可以用来处理具体的耗时任务逻辑的，但是但具体的差别在哪里呢？看一个小例子：
定义 MyCallable 实现了 Callable 接口，和之前 Runnable 的 run() 方法对比下， call() 方法是有返回值的哦，泛型就是返回值的类型：
一般会通过线程池来执行 Callable （线程池相关内容后边会讲到），执行结果就是一个 Future 对象：
可以看到，通过线程池执行 MyCallable 对象返回了一个 Future 对象，取出执行结果。
Future 是一个接口，从其内部的方法可以看出它提供了取消任务（有坑！！！）、判断任务是否完成、获取任务结果的功能：
Future 接口有一个 FutureTask 实现类，同时 FutureTask 也实现了 Runnable 接口，并提供了两个构造函数：
用 FutureTask 一个参数的构造函数来改造下上边的例子：
FutureTask 内部有一个 done() 方法，代表 Callable 中的任务已经结束，可以用来获取执行结果：
所以 Future + Callable 的组合可以更方便的获取子线程任务的执行结果，更好的控制任务的执行，主要的用法先说这么多了，其实 AsyncTask 内部也是类似的实现！
注意， Future 并不能取消掉运行中的任务，这点在后边的 AsyncTask 解析中有提到。
Java 中线程池的具体的实现类是 ThreadPoolExecutor ，继承了 Executor 接口，这些线程池在 Android 中也是通用的。使用线程池的好处：
常用的构造函数如下：
一个常规线程池可以按照如下方式来实现：
执行任务：
基于 ThreadPoolExecutor ，系统扩展了几类具有新特性的线程池：
线程池可以通过 execute() 、 submit() 方法开始执行任务，主要差别从方法的声明就可以看出，由于 submit() 有返回值，可以方便得到任务的执行结果：
要关闭线程池可以使用如下方法：
IntentService 是 Android 中一种特殊的 Service，可用于执行后台耗时任务，任务结束时会自动停止，由于属于系统的四大组件之一，相比一般线程具有较高的优先级，不容易被杀死。用法和普通 Service 基本一致，只需要在 onHandleIntent() 中处理耗时任务即可：
至于 HandlerThread，它是 IntentService 内部实现的重要部分，细节内容会在 IntentService 源码中说到。
IntentService 首次创建被启动的时候其生命周期方法 onCreate() 会先被调用，所以我们从这个方法开始分析：
这里出现了 HandlerThread 和 ServiceHandler 两个类，先搞明白它们的作用，以便后续的分析。
首先看 HandlerThread 的核心实现：
首先它继承了 Thread 类，可以当做子线程来使用，并在 run() 方法中创建了一个消息循环系统、开启消息循环。
ServiceHandler 是 IntentService 的内部类，继承了 Handler，具体内容后续分析：
现在回过头来看 onCreate() 方法主要是一些初始化的操作， 首先创建了一个 thread 对象，并启动线程，然后用其内部的 Looper 对象 创建一个 mServiceHandler 对象，将子线程的 Looper 和 ServiceHandler 建立了绑定关系，这样就可以使用 mServiceHandler 将消息发送到子线程去处理了。
生命周期方法 onStartCommand() 方法会在 IntentService 每次被启动时调用，一般会这里处理启动 IntentService 传递 Intent 解析携带的数据：
又调用了 start() 方法：
就是用 mServiceHandler 发送了一条包含 startId 和 intent 的消息，消息的发送还是在主线程进行的，接下来消息的接收、处理就是在子线程进行的：
当接收到消息时，通过 onHandleIntent() 方法在子线程处理 intent 对象， onHandleIntent() 方法执行结束后，通过 stopSelf(msg.arg1) 等待所有消息处理完毕后终止服务。
为什么消息的处理是在子线程呢？这里涉及到 Handler 的内部消息机制，简单的说，因为 ServiceHandler 使用的 Looper 对象就是在 HandlerThread 这个子线程类里创建的，并通过 Looper.loop() 开启消息循环，不断从消息队列（单链表）中取出消息，并执行，截取 loop() 的部分源码：
dispatchMessage() 方法间接会调用 handleMessage() 方法，所以最终 onHandleIntent() 就在子线程中划线执行了，即 HandlerThread 的 run() 方法。
这就是 IntentService 实现的核心，通过 HandlerThread + Hanlder 把启动 IntentService 的 Intent 从主线程切换到子线程，实现让 Service 可以处理耗时任务的功能！
AsyncTask 是 Android 中轻量级的异步任务抽象类，它的内部主要由线程池以及 Handler 实现，在线程池中执行耗时任务并把结果通过 Handler 机制中转到主线程以实现UI操作。典型的用法如下：
从 Android3.0 开始，AsyncTask 默认是串行执行的：
如果需要并行执行可以这么做：
AsyncTask 的源码不多，还是比较容易理解的。根据上边的用法，可以从 execute() 方法开始我们的分析：
看到 @MainThread 注解了吗？所以 execute() 方法需要在主线程执行哦！
进而又调用了 executeOnExecutor() ：
可以看到，当任务正在执行或者已经完成，如果又被执行会抛出异常！回调方法 onPreExecute() 最先被执行了。
传入的 sDefaultExecutor 参数，是一个自定义的串行线程池对象，所有任务在该线程池中排队执行：
可以看到 SerialExecutor 线程池仅用于任务的排队， THREAD_POOL_EXECUTOR 线程池才是用于执行真正的任务，就是我们线程池部分讲到的 ThreadPoolExecutor ：
再回到 executeOnExecutor() 方法中，那么 exec.execute(mFuture) 就是触发线程池开始执行任务的操作了。
那 executeOnExecutor() 方法中的 mWorker 是什么？ mFuture 是什么？答案在 AsyncTask 的构造函数中：
原来 mWorker 是一个 Callable 对象， mFuture 是一个 FutureTask 对象，继承了 Runnable 接口。所以 mWorker 的 call() 方法会在 mFuture 的 run() 方法中执行，所以 mWorker 的 call() 方法在线程池得到执行！
同时 doInBackground() 方法就在 call() 中方法，所以我们自定义的耗时任务逻辑得到执行，不就是我们第二部分讲的那一套吗！
doInBackground() 的返回值会传递给 postResult() 方法：
就是通过 Handler 将最终的耗时任务结果从子线程发送到主线程，具体的过程是这样的， getHandler() 得到的就是 AsyncTask 构造函数中初始化的 mHandler ， mHander 又是通过 getMainHandler() 赋值的：
可以在看到 sHandler 是一个 InternalHandler 类对象：
所以 getHandler() 就是在得到在主线程创建的 InternalHandler 对象，所以
就可以完成耗时任务结果从子线程到主线程的切换，进而可以进行相关UI操作了。
当消息是 MESSAGE_POST_RESULT 时，代表任务执行完成， finish() 方法被调用：
如果任务没有被取消的话执行 onPostExecute() ，否则执行 onCancelled() 。
如果消息是 MESSAGE_POST_PROGRESS ， onProgressUpdate() 方法被执行，根据之前的用法可以 onProgressUpdate() 的执行需要我们手动调用 publishProgress() 方法，就是通过 Handler 来发送进度数据：
进行中的任务如何取消呢？AsyncTask 提供了一个 cancel(boolean mayInterruptIfRunning) ，参数代表是否中断正在执行的线程任务，但是呢并不靠谱， cancel() 的方法注释中有这么一段：
大致意思就是调用 cancel() 方法后， onCancelled(Object) 回调方法会在 doInBackground() 之后被执行而 onPostExecute() 将不会被执行，同时你应该 doInBackground() 回调方法中通过 isCancelled() 来检查任务是否已取消，进而去终止任务的执行！
所以只能自己动手了：
AsyncTask 整体的实现流程就这些了，源码是最好的老师，自己跟着源码走一遍有些问题可能就豁然开朗了！
一般我们想要执行耗时操作都会想开启Thread子线程去处理，但是多次创建和销毁线程是很耗系统资源的。为了解决这一问题，我们可以自己构建一个循环线程，在线程当中创建一个Looper轮循器，来进行消息的轮循， 当有耗时任务需要投放到该循环线程时，线程就会执行耗时任务，任务执行完成之后，线程又会处于阻塞等待状态，不会马上销毁掉，直到下一个耗时任务被投放进来；即通过阻塞和等待来保证性能最优，为此Google为我们封装好了HandlerThread框架。
HandlerThread本质上就是一个Thread子线程，不同的是在Thread内部有一个Looper开启了轮循器；
HandlerThread = Handler + Thread + Looper
由于一般的Thread没有开启Looper轮循器，所以不能在子线程中创建handler，因为没有对应的MessageQueue与handler相关联，而MessageQueue是由Looper进行维护的；如果想在子线程中创建handler，必须先通过Looper.prepare()创建一个Looper，再通过Looper.loop()开启循环，才能使用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中有主线程和子线程的区分。主线程又称为UI线程，主要是处理一些和界面相关的事情，而子线程主要是用于处理一些耗时比较大的一些任务，例如一些网络操作，IO请求等。如果在主线程中处理这些耗时的任务，则有可能会出现ANR现象（App直接卡死）。
线程池，从名字的表明含义上我们知道线程池就是包含线程的一个池子，它起到新建线程、管理线程、调度线程等作用。
既然Android中已经有了线程的概念，那么为什么需要使用线程池呢？我们从两个方面给出使用线程池的原因。
在Android中线程池就是ThreadPoolExecutor对象。我们先来看一下ThreadPoolExecutor的构造函数。
我们分别说一下当前的几个参数的含义：
第一个参数corePoolSize为 核心线程数 ，也就是说线程池中至少有这么多的线程，即使存在的这些线程没有执行任务。但是有一个例外就是，如果在线程池中设置了allowCoreThreadTimeOut为true，那么在 超时时间（keepAliveTime） 到达后核心线程也会被销毁。
第二个参数maximumPoolSize为 线程池中的最大线程数 。当活动线程数达到这个数后，后续添加的新任务会被阻塞。
第三个参数keepAliveTime为 线程的保活时间 ，就是说如果线程池中有多于核心线程数的线程，那么在线程没有任务的那一刻起开始计时，如果超过了keepAliveTime，还没有新的任务过来，则该线程就要被销毁。同时如果设置了allowCoreThreadTimeOut为true，该时间也就是上面第一条所说的 超时时间 。
第四个参数unit为 第三个参数的计时单位 ，有毫秒、秒等。
第五个参数workQueue为 线程池中的任务队列 ，该队列持有由execute方法传递过来的Runnable对象（Runnable对象就是一个任务）。这个任务队列的类型是BlockQueue类型，也就是阻塞队列，当队列的任务数为0时，取任务的操作会被阻塞；当队列的任务数满了（活动线程达到了最大线程数），添加操作就会阻塞。
第六个参数threadFactory为 线程工厂 ，当线程池需要创建一个新线程时，使用线程工厂来给线程池提供一个线程。
第七个参数handler为 拒绝策略 ，当线程池使用有界队列时（也就是第五个参数），如果队列满了，任务添加到线程池的时候的一个拒绝策略。
可以看到FixedThreadPool的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出FixedThreadPool的几个特点：
可以看到CacheThreadPool的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出CacheThreadPool的几个特点：
可以看到ScheduledThreadPoolExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出ScheduledThreadPoolExecutor的几个特点：
可以看到SingleThreadExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出SingleThreadExecutor的几个特点：