android任务队列

① android 线程执行完会主动销毁吗

不会自动销毁，除非主动关闭它们。
一、销毁的方法
1、通过线程
Hanlder是线程与Activity通信的桥梁,利用handler接收到任务线程，放到任务队列里面派对执行。
//调用该任务线程的run() 方法执行任务线程。
Handler updateBarHandler =new handler();
handler.post(Runnable Thread);
//移除handler里的任务线程,调用线程的stop()方法，销毁线程。
handler.removecallbacks(Runnable Thread);
2、通过Timer
通过以下四种方法终止一个timer线程：
a）调用timer的cancle方法。可以从程序的任何地方调用此方法，甚至在一个timer task的run方法里；
b）让timer线程成为一个daemon线程（可以在创建timer时使用new Timer(true)达到这个目地），这样当程序只有daemon线程的时候，它就会自动终止运行；
c）当timer相关的所有task执行完毕以后，删除所有此timer对象的引用（置成null），这样timer线程也会终止；
d）调用System.exit方法，使整个程序（所有线程）终止。

② android怎么实现任务队列

主要就是有一个线程队列，维护这些任务，这里没有用到Queue而是用List是考虑到显示的问题。

③ 请简述什么是android事件处理，并分析两种android事件处理机制的实现过程和区别

UI编程通常都会伴随事件处理，Android也不例外，它提供了两种方式的事件处理：基于回调的事件处理和基于监听器的事件处理。

对于基于监听器的事件处理而言，主要就是为Android界面组件绑定特定的事件监听器；对于基于回调的事件处理而言，主要做法是重写Android组件特定的回调函数，Android大部分界面组件都提供了事件响应的回调函数，我们主要重写它们就行。

一 基于监听器的事件处理

相比于基于回调的事件处理，这是更具“面向对象”性质的事件处理方式。在监听器模型中，主要涉及三类对象：

1）事件源Event Source：产生事件的来源，通常是各种组件，如按钮，窗口等。

2）事件Event：事件封装了界面组件上发生的特定事件的具体信息，如果监听器需要获取界面组件上所发生事件的相关信息，一般通过事件Event对象来传递。

3）事件监听器Event Listener：负责监听事件源发生的事件，并对不同的事件做相应的处理。

基于监听器的事件处理机制是一种委派式Delegation的事件处理方式，事件源将整个事件委托给事件监听器，由监听器对事件进行响应处理。这种处理方式将事件源和事件监听器分离，有利于提供程序的可维护性。

举例：

View类中的OnLongClickListener监听器定义如下：（不需要传递事件）

[java] view plainprint?

public interface OnLongClickListener {

boolean onLongClick(View v);

}

public interface OnLongClickListener {
boolean onLongClick(View v);
}

View类中的OnLongClickListener监听器定义如下：（需要传递事件MotionEvent）

[java] view plainprint?

public interface OnTouchListener {

boolean onTouch(View v, MotionEvent event);

}

public interface OnTouchListener {
boolean onTouch(View v, MotionEvent event);
}

二 基于回调的事件处理

相比基于监听器的事件处理模型，基于回调的事件处理模型要简单些，该模型中，事件源和事件监听器是合一的，也就是说没有独立的事件监听器存在。当用户在GUI组件上触发某事件时，由该组件自身特定的函数负责处理该事件。通常通过重写Override组件类的事件处理函数实现事件的处理。

举例：

View类实现了KeyEvent.Callback接口中的一系列回调函数，因此，基于回调的事件处理机制通过自定义View来实现，自定义View时重写这些事件处理方法即可。

[java] view plainprint?

public interface Callback {

// 几乎所有基于回调的事件处理函数都会返回一个boolean类型值，该返回值用于

// 标识该处理函数是否能完全处理该事件

// 返回true，表明该函数已完全处理该事件，该事件不会传播出去

// 返回false，表明该函数未完全处理该事件，该事件会传播出去

boolean onKeyDown(int keyCode, KeyEvent event);

boolean onKeyLongPress(int keyCode, KeyEvent event);

boolean onKeyUp(int keyCode, KeyEvent event);

boolean onKeyMultiple(int keyCode, int count, KeyEvent event);

}

public interface Callback {
// 几乎所有基于回调的事件处理函数都会返回一个boolean类型值，该返回值用于
// 标识该处理函数是否能完全处理该事件
// 返回true，表明该函数已完全处理该事件，该事件不会传播出去
// 返回false，表明该函数未完全处理该事件，该事件会传播出去
boolean onKeyDown(int keyCode, KeyEvent event);
boolean onKeyLongPress(int keyCode, KeyEvent event);
boolean onKeyUp(int keyCode, KeyEvent event);
boolean onKeyMultiple(int keyCode, int count, KeyEvent event);
}

三 比对

基于监听器的事件模型符合单一职责原则，事件源和事件监听器分开实现；

Android的事件处理机制保证基于监听器的事件处理会优先于基于回调的事件处理被触发；

某些特定情况下，基于回调的事件处理机制会更好的提高程序的内聚性。

四 基于自定义监听器的事件处理流程

在实际项目开发中，我们经常需要自定义监听器来实现自定义业务流程的处理，而且一般都不是基于GUI界面作为事件源的。这里以常见的app自动更新为例进行说明，在自动更新过程中，会存在两个状态：下载中和下载完成，而我们的程序需要在这两个状态做不同的事情，“下载中”需要在UI界面上实时显示软件包下载的进度，“下载完成”后，取消进度条的显示。这里进行一个模拟，重点在说明自定义监听器的事件处理流程。

4.1）定义事件监听器如下：

④ android开发中的handler队列的疑问。

就是多线程，如果你在一个ui里做很多事情，这些事情都在ui的线程里执行，会显得很卡，让ui只做显示，一些数据的处理交给另外一个线程会提高ui的显示，不会造成主线程堵塞，要知道在界面里ui线程才是主线程

⑤ android中主线程会创建消息队列吗

一、Handler的定义: Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。 通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示"强制关闭". 这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的. 这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。 二、Handler一些特点 handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程), 也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。 三、Handler中分发消息的一些方法 post(Runnable) postAtTime(Runnable,long) postDelayed(Runnable long) post类方法允许你排列一个Runnable对象到主线程队列中 sendEmptyMessage(int) sendMessage(Message) sendMessageAtTime(Message,long) sendMessageDelayed(Message,long) sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新. 四、应用实例： 1，传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。 在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。 2，传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。 Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。 另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。 视频教程中的例子： 1. public class HandlerActivity extends Activity { 2. 3. //声明两个按钮控件 4. private Button startButton = null; 5. private Button endButton = null; 6. @Override 7. public void onCreate(Bundle savedInstanceState) { 8. super.onCreate(savedInstanceState); 9. setContentView(R.layout.main); 10. //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器 11. startButton = (Button)findViewById(R.id.startButton); 12. startButton.setOnClickListener(new StartButtonListener()); 13. endButton = (Button)findViewById(R.id.endButton); 14. endButton.setOnClickListener(new EndButtonListener()); 15. 16. } 17. class StartButtonListener implements OnClickListener{ 18. 19. @Override 20. public void onClick(View v) { 21. //调用Handler的post方法，将要执行的线程对象添加到队列当中 22. handler.post(updateThread); 23. } 24. 25. } 26. 27. class EndButtonListener implements OnClickListener{ 28. 29. @Override 30. public void onClick(View v) { 31. handler.removeCallbacks(updateThread); 32. } 33. 34. } 35. //创建一个Handler对象 36. Handler handler = new Handler(); 37. //将要执行的操作写在线程对象的run方法当中 38. Runnable updateThread = new Runnable(){ 39. 40. @Override 41. public void run() { 42. System.out.println("UpdateThread"); 43. //在run方法内部，执行postDelayed或者是post方法 44. handler.postDelayed(updateThread, 3000); 45. } 46. 47. }; 48. } 程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。 3， Handler和多线程 post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。 这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。 1. public class HandlerTest2 extends Activity { 2. 3. @Override 4. protected void onCreate(Bundle savedInstanceState) { 5. // TODO Auto-generated method stub 6. super.onCreate(savedInstanceState); 7. setContentView(R.layout.main); 8. //打印了当前线程的ID 9. System.out.println("Activity-->" + Thread.currentThread().getId()); 10. //生成一个HandlerThread对象 11. HandlerThread handlerThread = new HandlerThread("handler_thread"); 12. //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程; 13. handlerThread.start(); 14. //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。 15. // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程 16. ，可以处理消息循环； 其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是 17. 一一对应的。 18. MyHandler myHandler = new MyHandler(handlerThread.getLooper()); 19. Message msg = myHandler.obtainMessage(); 20. //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象 21. Bundle b = new Bundle(); 22. b.putInt("age", 20); 23. b.putString("name", "Jhon"); 24. msg.setData(b); 25. msg.sendToTarget(); //将msg发送到myHandler 26. } 27. 28. //定义类 29. class MyHandler extends Handler{ 30. public MyHandler(){ 31. 32. } 33. 34. public MyHandler(Looper looper){ 35. super(looper); 36. } 37. @Override 38. public void handleMessage(Message msg) { 39. Bundle b = msg.getData(); 40. int age = b.getInt("age"); 41. String name = b.getString("name"); 42. System.out.println("age is " + age + ", name is" + name); 43. System.out.println("Handler--->" + Thread.currentThread().getId()); 44. System.out.println("handlerMessage"); 45. } 46. } 47. } 这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。 这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。 另外再强调一遍，在UI线程（主线程）中： mHandler=new Handler(); mHandler.post(new Runnable(){ void run(){ //执行代码.. } }); 这个线程其实是在UI线程之内运行的，并没有新建线程。 常见的新建线程的方法是： Thread thread = new Thread(); thread.start(); HandlerThread thread = new HandlerThread("string"); thread.start();

⑥ 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 4.1（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. Executors.newFixedThreadPool()

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

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

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

2. Executors.newCachedThreadPool()

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

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

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

3. Executors.newScheledThreadPool()

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

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

4. Executors.newSingleThreadExecutor()

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

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

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

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

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

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

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

⑦ android 网络请求为什么要使用队列

Toast必须出现在主线程上。您可以使用 new Handler(Looper.getMainLooper()) 来生成一个主线程 handler 从任何后台线程，然后使用它发布 toast 主线程的工作。 代码像这会适合您： public static void backgroundThreadShortToast(final Context context, final String msg) { if (context != null && msg != null) { new Handler(Looper.getMainLooper()).post(new Runnable() { @Override public void run() { Toast.makeText(context, msg, Toast.LENGTH_SHORT).show(); } }); } }

⑧ Android 重学系列 View的绘制流程(六) 硬件渲染(上)

本文开始聊聊Android中的硬件渲染。如果跟着我的文章顺序，从SF进程到App进程的绘制流程一直阅读，我们到这里已经有了一定的基础，可以试着进行横向比对如Chrome浏览器渲染流程，看看软件渲染，硬件渲染，SF合成都做了什么程度的优化。

先让我们回顾一下负责硬件渲染的主体对象ThreadedRenderer在整个绘制流程中做了哪几个步骤。

在硬件渲染的过程中，有一个很核心的对象RenderNode，作为每一个View绘制的节点对象。

当每一次进行准备进行绘制的时候，都会雷打不动执行如下三个步骤：

如果遇到什么问题欢迎来到 https://www.jianshu.com/p/c84bfa909810 下进行讨论

实际上整个硬件渲染的设计还是比较庞大。因此本文先聊聊ThreadedRender整个体系中主要对象的构造以及相关的原理。

首先来认识下面几个重要的对象有一个大体的印象。

在Java层中面向Framework中，只有这么多，下面是一一映射的简图。

能看到实际上RenderNode也会跟着View 树的构建同时一起构建整个显示层级。也是因此ThreadedRender也能以RenderNode为线索构建出一套和软件渲染一样的渲染流程。

仅仅这样？如果只是这么简单，知道我习惯的都知道，我喜欢把相关总结写在最后。如果把总揽写在正文开头是因为设计比较繁多。因为我们如果以流水线的形式进行剖析容易造成迷失细节的困境。

让我继续介绍一下，在硬件渲染中native层的核心对象。

如下是一个思维导图：

有这么一个大体印象后，就不容易迷失在源码中。我们先来把这些对象的实例化以及上面列举的ThreadedRenderer在ViewRootImpl中执行行为的顺序和大家来聊聊其原理，先来看看ThreadedRenderer的实例化。

当发现mSurfaceHolder为空的时候会调用如下函数：

而这个方法则调用如下的方法对ThreadedRenderer进行创建：

文件：/ frameworks / base / core / java / android / view / ThreadedRenderer.java

能不能创建的了ThreadedRenderer则决定于全局配置。如果ro.kernel.qemu的配置为0，说明支持OpenGL 则可以直接返回true。如果qemu.gles为-1说明不支持OpenGL es返回false，只能使用软件渲染。如果设置了qemu.gles并大于0，才能打开硬件渲染。

我们能看到ThreadedRenderer在初始化，做了三件事情：

关键是看1-3点中ThreadRenderer都做了什么。

文件：/ frameworks / base / core / jni / android_view_ThreadedRenderer.cpp

能看到这里是直接实例化一个RootRenderNode对象，并把指针的地址直接返回。

能看到RootRenderNode继承了RenderNode对象，并且保存一个JavaVM也就是我们所说的Java虚拟机对象，一个java进程全局只有一个。同时通过getForThread方法，获取ThreadLocal中的Looper对象。这里实际上拿的就是UI线程的Looper。

在这个构造函数有一个mDisplayList十分重要，记住之后会频繁出现。接着来看看RenderNode的头文件：
文件：/ frameworks / base / libs / hwui / RenderNode.h

实际上我把几个重要的对象留下来：

文件：/ frameworks / base / core / java / android / view / RenderNode.java

能看到很简单，就是包裹一个native层的RenderNode返回一个Java层对应的对象开放Java层的操作API。

能看到这个过程生成了两个对象：

这个对象实际上让RenderProxy持有一个创建动画上下文的工厂。RenderProxy可以通过ContextFactoryImpl为每一个RenderNode创建一个动画执行对象的上下文AnimationContextBridge。

文件：/ frameworks / base / libs / hwui / renderthread / RenderProxy.cpp

在这里有几个十分重要的对象被实例化，当然这几个对象在聊TextureView有聊过( SurfaceView和TextureView 源码浅析 )：

我们依次看看他们初始化都做了什么。

文件：/ frameworks / base / libs / hwui / renderthread / RenderThread.cpp

能看到其实就是简单的调用RenderThread的构造函数进行实例化，并且返回对象的指针。

RenderThread是一个线程对象。先来看看其头文件继承的对象：
文件：/ frameworks / base / libs / hwui / renderthread / RenderThread.h

其中RenderThread的中进行排队处理的任务队列实际上是来自ThreadBase的WorkQueue对象。

文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h

ThreadBase则是继承于Thread对象。当调用start方法时候其实就是调用Thread的run方法启动线程。

另一个更加关键的对象，就是实例化一个Looper对象到WorkQueue中。而直接实例化Looper实际上就是新建一个Looper。但是这个Looper并没有获取当先线程的Looper，这个Looper做什么的呢？下文就会揭晓。

WorkQueue把一个Looper的方法指针设置到其中，其作用可能是完成了某一件任务后唤醒Looper继续工作。

而start方法会启动Thread的run方法。而run方法最终会走到threadLoop方法中，至于是怎么走进来的，之后有机会会解剖虚拟机的源码线程篇章进行讲解。

在threadloop中关键的步骤有如下四个：

在这个过程中创建了几个核心对象：

另一个核心的方法就是，这个方法为WorkQueue的Looper注册了监听：

能看到在这个Looper中注册了对DisplayEventReceiver的监听，也就是Vsync信号的监听，回调方法为displayEventReceiverCallback。

我们暂时先对RenderThread的方法探索到这里，我们稍后继续看看回调后的逻辑。

文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h

能看到这里的逻辑很简单实际上就是调用Looper的pollOnce方法，阻塞Looper中的循环，直到Vsync的信号到来才会继续往下执行。详细的可以阅读我写的 Handler与相关系统调用的剖析 系列文章。

文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h

实际上调用的是WorkQueue的process方法。

文件：/ frameworks / base / libs / hwui / thread / WorkQueue.h

能看到这个过程中很简单，几乎和Message的loop的逻辑一致。如果Looper的阻塞打开了，则首先找到预计执行时间比当前时刻都大的WorkItem。并且从mWorkQueue移除，最后添加到toProcess中，并且执行每一个WorkItem的work方法。而每一个WorkItem其实就是通过从某一个压入方法添加到mWorkQueue中。

到这里，我们就明白了RenderThread中是如何消费渲染任务的。那么这些渲染任务又是哪里诞生呢？

上文聊到了在RenderThread中的Looper会监听Vsync信号，当信号回调后将会执行下面的回调。

能看到这个方法的核心实际上就是调用drainDisplayEventQueue方法，对ui渲染任务队列进行处理。

能到在这里mVsyncRequested设置为false，且mFrameCallbackTaskPending将会设置为true，并且调用queue的postAt的方法执行ui渲染方法。

还记得queue实际是是指WorkQueue，而WorkQueue的postAt方法实际实现如下：
/ frameworks / base / libs / hwui / thread / WorkQueue.h

情景带入，当一个Vsync信号达到Looper的监听者，此时就会通过WorkQueue的drainDisplayEventQueue 压入一个任务到队列中。

每一个默认的任务都是执行dispatchFrameCallback方法。这里的判断mWorkQueue中是否存在比当前时间更迟的时刻，并返回这个WorkItem。如果这个对象在头部needsWakeup为true，说明可以进行唤醒了。而mWakeFunc这个方法指针就是上面传下来：

把阻塞的Looper唤醒。当唤醒后就继续执行WorkQueue的process方法。也就是执行dispatchFrameCallbacks方法。

在这里执行了两个事情：

先添加到集合中，在上面提到过的threadLoop中，会执行如下逻辑：

如果大小不为0，则的把中的IFrameCallback全部迁移到mFrameCallbacks中。

而这个方法什么时候调用呢？稍后就会介绍。其实这部分的逻辑在TextureView的解析中提到过。

接下来将会初始化一个重要对象：

这个对象名字叫做画布的上下文，具体是什么上下文呢？我们现在就来看看其实例化方法。
文件：/ frameworks / base / libs / hwui / renderthread / CanvasContext.cpp

文件：/ device / generic / goldfish / init.ranchu.rc

在init.rc中默认是opengl，那么我们就来看看下面的逻辑：

首先实例化一个OpenGLPipeline管道，接着OpenGLPipeline作为参数实例化CanvasContext。

文件：/ frameworks / base / libs / hwui / renderthread / OpenGLPipeline.cpp

能看到在OpenGLPipeline中，实际上就是存储了RenderThread对象，以及RenderThread中的mEglManager。透过OpenGLPipeline来控制mEglManager进而进一步操作OpenGL。

做了如下操作：

文件：/ frameworks / base / libs / hwui / renderstate / RenderState.cpp

文件：/ frameworks / base / libs / hwui / renderthread / DrawFrameTask.cpp

实际上就是保存这三对象RenderThread；CanvasContext；RenderNode。

文件：/ frameworks / base / core / jni / android_view_ThreadedRenderer.cpp

能看到实际上就是调用RenderProxy的setName方法给当前硬件渲染对象设置名字。

文件：/ frameworks / base / libs / hwui / renderthread / RenderProxy.cpp

能看到在setName方法中，实际上就是调用RenderThread的WorkQueue，把一个任务队列设置进去，并且调用runSync执行。

能看到这个方法实际上也是调用post执行排队执行任务，不同的是，这里使用了线程的Future方式，阻塞了执行，等待CanvasContext的setName工作完毕。

⑨ android 主进程销毁了，线程会不会也销毁

不会自动销毁，除非主动关闭它们。
一、销毁的方法
1、通过线程
Hanlder是线程与Activity通信的桥梁,利用handler接收到任务线程，放到任务队列里面派对执行。
//调用该任务线程的run() 方法执行任务线程。
Handler updateBarHandler =new handler();
handler.post(Runnable Thread);
//移除handler里的任务线程,调用线程的stop()方法，销毁线程。
handler.removecallbacks(Runnable Thread);
2、通过Timer
通过以下四种方法终止一个timer线程：
a）调用timer的cancle方法。可以从程序的任何地方调用此方法，甚至在一个timer task的run方法里；
b）让timer线程成为一个daemon线程（可以在创建timer时使用new Timer(true)达到这个目地），这样当程序只有daemon线程的时候，它就会自动终止运行；
c）当timer相关的所有task执行完毕以后，删除所有此timer对象的引用（置成null），这样timer线程也会终止；
d）调用System.exit方法，使整个程序（所有线程）终止。

⑩ Android线程池的使用

在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的几个特点：

可以看到ScheledThreadPoolExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出ScheledThreadPoolExecutor的几个特点：

可以看到SingleThreadExecutor的构建调用了ThreadPoolExecutor的构造函数。从上面的调用中可以看出SingleThreadExecutor的几个特点：