一、基础知识：
- Android 的线程分两种：主线程（又称：UI线程）和子线程（又称工作线程，即普通的new Thread）。
- 主线程由应用程序启动时自动创建，用户使用app进行界面交互、获取操作结果，就是基于UI线程。如：activity跳转、设置TextView文本、showToast等。而子线程则通过new Thread创建。
- UI线程执行代码效率越高，界面响应越快，用户感觉就越流畅。为了更好的用户体验，Android系统中的耗时操作（包括耗性能、复杂数学运算、大文件下载等）我们一般都在子线程中执行，从而避免影响用户点击或者布局渲染等处理。在Android4.4版本之后，如果直接在主线程进行网络请求，系统会抛出NetWrokOnMainThreadException异常，以此要求我们使用子线程处理。主线程应做到专线程专用：只处理UI相关操作，否则程序会报ANR错误。
- 同步和异步的区别：
- 同步：在UI线程下载图片，下载成功后，在UI线程更新图片
- 异步：在UI线程new一个子线程，在子线程执行下载操作，成功后，子线程发通知告诉UI线程，UI线程显示下载图片。
上面提到：子线程作用是执行比较耗时的操作，如联网下载数据等，但Android子线程是不安全的，只能在主线程中更新UI。相信聪明的你看到这里，一定能够体会“异步”的作用了！那“子线程发通知告诉UI线程”是怎么实现呢？这就要提到handler了。
二、Handler的作用：
在子线程发送消息(Message)，通知创建它的线程（通常是UI线程）处理数据结果。
三、如何使用Handler：
public class MainActivity extends Activity {
private static final int MAKE_TOAST = 0x01;
// handler构造函数为空，等同于new Handler(getMainLooper())，与Activity所在的UI线程关联
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MAKE_TOAST:
Toast.makeText(MainActivity.this, "hello", Toast.LENGTH_SHORT).show();
break;
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
HttpUtils.doGet("https://www.baidu.com/", new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
mHandler.sendEmptyMessageDelayed(MAKE_TOAST,200); // handler发送消息
}
});
}
}
四、开发者容易犯的错误：
获取数据后更新UI的问题，比如：在onClick事件（运行在UI线程）中，执行以下代码（doGet方法执行了new Thread，创建了子线程），在获取网络信息后，需要弹出一个Toast
HttpUtils.doGet("https://www.baidu.com/", new Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
Toast.makeText(OkHttpActivity.this,"",Toast.LENGTH_SHORT).show();
}
});/*例子2，运行时报java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()异常*/
new Thread(new Runnable(){
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
i++;
}
Handler handler=new Handler(); //Handler放到当前新线程中
handler.sendEmptyMessage(3);
}
}).start();
直接在在新的线程中创建Handler和发送消息，这是不允许的
这是因为Android规定了只允许UI线程修改Activity里的UI组件，而我们刚才的操作在子线程中修改Activity里的UI组件，才会导致UI操作的线程不安全，并报出错误。
但细心的朋友会问：前面 “三、Handler常见用法” 示例中，为什么不会报错，在子线程用就出错了？
奥妙在于：
Android系统会自动为主线程创建Looper对象，开启消息循环，
但子线程默认没有开启消息循环。
如果子线程要使用handler，应该手动开启消息循环。
Looper对象通过MessageQueue来存放消息和事件。
一个线程只能有一个Looper，对应一个MessageQueue。
然后通过Looper.loop() 让Looper开始工作，从消息队列里取消息，处理消息。
注意：写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop才会中止，其后的代码才能得以运行。
五、Handler工作原理
一）Android消息机制的相关概念
- 主线程（UI线程）
定义：当程序第一次启动时，Android会同时启动一条主线程（Main Thread）
作用：主线程主要负责处理与UI相关的事件
- Message（消息）
定义：Handler接收和处理的消息对象（Bean对象）
作用：通信时相关信息的存放和传递
- ThreadLocal
定义：线程内部的数据存储类
作用：负责存储和获取本线程的Looper
- Message Queue（消息队列）
定义：采用单链表的数据结构来存储消息列表
作用：用来存放通过Handler发过来的Message，按照先进先出执行
- Handler（处理者）
定义：Message的主要处理者
作用：负责发送Message到消息队列&处理Looper分派过来的Message
- Looper（循环器）
定义：扮演Message Queue和Handler之间桥梁的角色
作用：
消息循环：循环取出Message Queue的Message
消息派发：将取出的Message交付给相应的Handler
二）图片解读它们之间的关系
三）文字解读它们之间的关系
Looper中存放有MessageQueen，MessageQueen中又有很多Message，当我们的Handler发送消息的时候，会获取当前的Looper，并在当前的Looper的MessageQueen当中存放我们发送的消息，而我们的MessageQueen也会在Looper的带动下，一直循环的读取Message信息，并将Message信息发送给Handler，并执行HandlerMessage()方法
其实这是一个循环的过程，读懂这句话和看懂图解很重要，会给我们下面的源码分析带来很大的帮助，所以建议大家先读懂前面的内容。
Android消息机制的通信流程
源码分析请参考后面“Looper源码分析”。
六、子线程之间使用Handler
package lib.com.myapplication;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
public class MainActivity extends AppCompatActivity {
// 注意：这两个虽然属于Activity变量，但它们是在子线程创建的，
// 创建时调用new Handler()构造函数取“所在线程的looper”，
// 即等效于 new Hanlder(子线程.looper)
private Handler handler1 ;
private Handler handler2 ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new MyThread1().start();
new MyThread2().start();
}
class MyThread1 extends Thread {
@Override
public void run() {
super.run();
// 为当前线程创建looper
Looper.prepare();
// 关联Thread1 的 looper
handler1 = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
System.out.println( "threadName--" + Thread.currentThread().getName() + "messageWhat-"+ msg.what );
}
};
try {
sleep( 3000 );
} catch (InterruptedException e) {
e.printStackTrace();
}
handler2.sendEmptyMessage( 2 ) ; // 发送消息给子线程2
Looper.loop(); // 让Looper循环取消息，发送给handler，让handler处理
}
}
class MyThread2 extends Thread {
@Override
public void run() {
super.run();
Looper.prepare();
// 关联Thread2 的 looper
handler2 = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
System.out.println( "threadName--" + Thread.currentThread().getName() + "messageWhat-"+ msg.what );
}
};
try {
sleep( 4000 );
} catch (InterruptedException e) {
e.printStackTrace();
}
handler1.sendEmptyMessage( 5 ) ;
Looper.loop();
}
}
}
注意：
1、调用Looper类的 prepare() 方法可以为当前线程创建一个消息循环，调用loop() 方法使之处理信息，直到循环结束。
2、new Handler时，有几个构造函数可选，如果不选择Looper类对象参数，会获取当前线程的Looper对象，即将当前线程的消息循环作为Handler关联的消息循环。
3、消息处理机制中，消息存放在一个消息队列中，而线程围绕这个队列进入一个无限循环，直到程序退出。如果队列中有消息，线程就会把消息取出来，并分发给相应的Handler进行处理；如果队列中没有消息，线程就会进入空闲等待状态，等待下一个消息的到来。
七、HandlerThread介绍
顾名思义，Handler---->Thread，handler是修饰thread的，说明它是一个Thread线程类。
HandlerThread是一个内置 Looper 的Thread，让我们可以直接在线程中使用 Handler 来处理异步任务。
- HandlerThread将loop转到子线程中处理，说白了就是将分担MainLooper的工作量，降低了主线程的压力，使主界面更流畅。
- 开启一个线程起到多个线程的作用。处理任务是串行执行，按消息发送顺序进行处理。
相比多次使用new Thread(){…}.start()这样的方式节省系统资源。
但是由于每一个任务都将以队列的方式逐个被执行到，一旦队列中有某个任务执行时间过长，那么就会导致后续的任务都会被延迟处理。 - HandlerThread拥有自己的消息队列，它不会干扰或阻塞UI线程。
- 通过设置优先级就可以同步工作顺序的执行，而又不影响UI的初始化；
- 比较适用于单线程+异步队列的场景，比如IO读写操作，耗时不多而且也不会产生较大的阻塞。对于网络IO操作，HandlerThread并不适合，因为它只有一个线程，还得排队一个一个等着。
源代码不多：
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
//注意:指定线程优先级，是android.os.Process.xxx 而不是 java.lang.Thread.xxx 的优先级！
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
// 子类需要重写的方法，在这里做一些执行前的初始化工作
protected void onLooperPrepared() {
}
//获取当前线程的 Looper
//如果线程不是正常运行的就返回 null
//如果线程启动后，Looper 还没创建，就 wait() 等待 创建 Looper 后 notify
public Looper getLooper() {
if (!isAlive()) {
return null;
}
synchronized (this) {
while (isAlive() && mLooper == null) { //循环等待
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
//调用 start() 后就会执行的 run()
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare(); //帮我们创建了 Looper
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll(); //Looper 已经创建，唤醒阻塞在获取 Looper 的线程
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
// 执行loop内部方法，开始一直循环：消息队列，取消息给handler。不会执行下一句
// 注意：循环执行的是loop方法内部代码，而不是run方法
Looper.loop();
// 当外部执行HandlerThread.quit/quitSafely时，才会执行这句。
mTid = -1;
}
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}
public int getThreadId() {
return mTid;
}
}可以看到，
①HandlerThread 本质还是个 Thread，创建后别忘了调用 start()。
②在 run() 方法中创建了 Looper，调用 onLooperPrepared 后开启了循环
③我们要做的就是在子类中重写 onLooperPrepared，做一些初始化工作
④在创建 HandlerThread 时可以指定优先级，注意这里的参数是 Process.XXX 而不是 Thread.XXX
Process.setThreadPriority(int) A Linux priority level, from -20 for highest scheduling priority to 19 for lowest scheduling priority.
可选的值如下：
public static final int THREAD_PRIORITY_DEFAULT = 0;
public static final int THREAD_PRIORITY_LOWEST = 19;
public static final int THREAD_PRIORITY_BACKGROUND = 10;
public static final int THREAD_PRIORITY_FOREGROUND = -2;
public static final int THREAD_PRIORITY_DISPLAY = -4;
public static final int THREAD_PRIORITY_URGENT_DISPLAY = -8;
public static final int THREAD_PRIORITY_AUDIO = -16;
Looper.quit和Looper.quitSafely区别：
Looper.quit()：自API Level 1就存在，它会把MessageQueue消息池中所有的 延迟 + 非延迟 消息全部清空，无论是延迟消息（延迟消息是指通过sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息）还是非延迟消息。
Looper.quitSafely()：在API Level 18后加入，只会清空所有的延迟消息，并将所有的非延迟消息派发出去让Handler去处理.
两者共同点：只要调用，Looper就不再接收新的消息。这时候再通过Handler调用sendMessage或post等方法发送消息时均返回false，表示消息没有成功放入消息队列MessageQueue中，因为消息队列已经退出了。
HandlerThread的简单用法：
//1.初始化,参数为名字，也就是线程的名字，后面我们会结合源码来看
mHandlerThread = new HandlerThread("WorkThread");
//必须调用start方法，因为HandlerThread继承自Thread来启动线程
mHandlerThread.start();
//初始化Handler,只是传递了一个mHandlerThread内部的一个looper
mHandler = new Handler(mHandlerThread.getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.d("WorkThread", (Looper.getMainLooper() == Looper.myLooper()) + "," + msg.what);
}
};
//2.使用
public void send(View view) {
new SendThread(mHandler).start();
}
private final class SendThread extends Thread {
private Handler mHandler;
SendThread(Handler handler) {
this.mHandler = handler;
}
@Override
public void run() {
super.run();
for (int i = 0; i < 3; i++) {
mHandler.sendEmptyMessage(0x1);
SystemClock.sleep(1000);
}
}
}
//3.别忘记释放，停止Looper消息循环，内部还是调用了looper的quit,及时释放防止内存泄漏哦！！
mHandlerThread.quit();
八、防内存泄露：This Handler class should be static or leaks might occur
我们在handler对象创建的时候却会报警告：This Handler class should be static or leaks might occur
public class AutoActivity extends Activity {
// 创建handler时，Looper默认当前UI线程关联
Handler handler = new Handler(){
public void handleMessage(android.os.Message msg) {
};
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_auto);
}
}
意思是：Handler类应该为static类型，否则可能会造成内存泄漏。为什么会造成这种情况呢？
原因：从上文可以知道，handler的作用就是从这个消息队列中放入和取出消息。当我们通过handler将一个Message放入消息队列时，这个Message就会持有一个handler对象的引用。
Activity在被结束之后，MessageQueue并不会随之被结束，如果这个消息队列中存在Message，则导致持有handler的引用，但是又由于Activity被结束了，Message无法被处理，从而导致永久持有handler对象，handler永久持有Activity对象，于是发生内存泄漏。
为什么用might occur？
从Activity被结束后，到这个Message被取出来处理之前，这一段时间内（这个might用词非常准确，一方面消息可能处理完毕，另一方面延迟未处理才会出现这种情况，若不延迟那么久，可能性不算高。）这个Message会继续存活，但是这个Message持有handler的引用，而handler在Activity中创建，会持有Activity的引用，因而当Activity结束后，Activity对象并不能够被gc回收，因而出现内存泄漏。
上面的代码可能不够清晰，再来一段直白点的：
public class SampleActivity extends Activity {
private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 延时10分钟再发送消息
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
}
}, 60 * 10 * 1000);
finish(); // 关闭当前Activity
}
}
当Activity被finish()掉，这时activity总该被回收了吧？答案是否定的！因为Message 将存在于消息队列中长达10分钟的时间才会被执行到，这个Message持有一个对Handler的引用，Handler也会持有一个对于外部类（SampleActivity）的隐式引用，这些引用在Message被执行前将一直保持，这样会保证Activity的上下文不被垃圾回收机制回收，同时也会泄露应用程序的资源（views and resources）。
为什么为static类型就会解决这个问题呢？
因为在java中所有非静态的对象都会持有当前类的强引用，而静态对象则只会持有当前类的弱引用。声明为静态后，handler将会持有一个Activity的弱引用，而弱引用会很容易被gc回收，这样就能解决Activity结束后，gc却无法回收的情况。
所以解决这个警告就有几种方法：
一：将hanlder对象声明为静态的对象。
二：使用静态内部类，通过WeakReference实现对Activity的弱引用。具体实现看以下代码：
public class AutoActivity extends Activity { MyHandler handler = new MyHandler(this); @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_auto); } static class MyHandler extends Handler { WeakReference<AutoActivity> mactivity; public MyHandler(AutoActivity activity){ mactivity = new WeakReference<AutoActivity>(activity); } @Override public void handleMessage(Message msg) { super.handleMessage(msg); switch (msg.what) { case 100: //在这里面处理msg //通过mactivity.get()获取Activity的引用(即上下文context) break; default: break; } } } }
顺便说下软引用和弱引用的区别：
- 软引用（SoftReference）：当虚拟机内存不足时，将会回收它指向的对象；需要获取对象时，可以调用get方法
- 弱引用（WeakReference）：随时可能会被垃圾回收器回收，不一定要等到虚拟机内存不足时才强制回收。要获取对象时，同样可以调用get方法。
二. SoftReference：实现缓存机制
例如从网络上获取图片，然后将获取的图片显示的同时，通过软引用缓存起来。当下次再去网络上获取图片时，首先会检查要获取的图片缓存中是否存在，若存在，直接取出来，不需要再去网络上获取。
另附：
Looper源码分析
一、根据上面的例子，为什么Handler可以在主线程中直接可以使用呢？
因为主线程（UI线程）的Looper在应用程序开启时创建好了，即在ActivityThread.main方法中创建的，该函数为Android应用程序的入口
public static void main(String[] args) {
...
Process.setArgV0("<pre-initialized>");
//1. 创建消息循环Looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
//2. 执行消息循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
Looper中最为重要的两个方法：
- Looper.prepareMainLooper()：该方法是Looper对象的初始化
- Looper.loop()：该方法会循环取出Message Queue的Message，将取出的Message交付给相应的Handler（Looper的作用就体现在这里）
二、Looper.prepareMainLooper()
//在主线程中初始化Looper
public static void prepareMainLooper() {
//在这里会调用prepare(boolean quitAllowed)方法
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
//看下prepare(boolean quitAllowed)方法
private static void prepare(boolean quitAllowed) {
//判断sThreadLocal是否为null，否则抛出异常
//即Looper.prepare()方法不能被调用两次
//也就是说，一个线程中只能对应一个Looper实例
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//初始化Looper对象设置到ThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
//看下Looper的构造方法
private Looper(boolean quitAllowed) {
//创建了一个MessageQueue（消息队列）
//这说明，当创建一个Looper实例时，会自动创建一个与之配对的MessageQueue（消息队列）
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
整个Looper的初始化准备工作就完了，这里做了哪几件事：
Looper的创建会关联一个MessageQueen的创建
Looper对象只能被创建一次
Looper对象创建后被存放在sThreadLocal中
三、Looper.loop()
public static void loop() {
//myLooper()方法作用是返回sThreadLocal存储的Looper实例，如果me为null，loop()则抛出异常
//也就是说loop方法的执行必须在prepare方法之后运行
//也就是说，消息循环必须要先在线程当中创建Looper实例
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//获取looper实例中的mQueue（消息队列）
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
//进入消息循环
for (;;) {
//next()方法用于取出消息队列里的消息
//如果取出的消息为空，则线程阻塞
Message msg = queue.next();
if (msg == null) {
return;
}
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
//消息派发：把消息派发给msg的target属性，然后用dispatchMessage方法去处理
//Msg的target其实就是handler对象，下面会继续分析
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
//释放消息占据的资源
msg.recycleUnchecked();
}
}
整个Looper的循环过程就完了，这里做了哪几件事：
取出Looper和MessageQueen
进入消息循环，有消息则分发出去
消息资源的回收
四、Looper的退出
当然Looper也提供了两个方法可以退出一个Looper：
quit()：quit会直接退出Looper
quitSafety()：quitSafety只是设定一个退出标记，然后把消息队列中的已有消息处理完毕后退出Looper
MessageQueen源码分析
一、由于MessageQueen是用来存放Message的，那么是如何存储Message的呢？
由于Handler使用Post()方法将Message传递到MessageQueen中，在MessageQueen中会使用enqueueMessage()方法存储Message，其实现的方式是通过单链表的数据结构来存储消息列表
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p;
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
整个进队列的过程就完了，这里做了哪几件事：
首先判断消息队列里有没有消息，没有的话则将当前插入的消息作为队头，并且这时消息队列如果处于等待状态的话则将其唤醒
若是在中间插入，则根据Message创建的时间进行插入
二、既然MessageQueen存了消息之后，是如何提供取出来的方法的呢？
我们知道存消息是Handler存进来的，那么取消息就应该是Looper中取了，从Looper的源码可以看出，消息就是在Looper中取出的，其实现是用MessageQueen里面的next()方法
Message next() {
......
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，这时候消息队列处于等待状态。
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
//按照我们设置的时间取出消息
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// 如果消息队列中没有消息，将nextPollTimeoutMillis设为-1，下次循环消息队列则处于等待状态
nextPollTimeoutMillis = -1;
}
//退出消息队列，返回null，这时候Looper中的消息循环也会终止。
if (mQuitting) {
dispose();
return null;
}
......
}
.....
}
}
三、在MessageQueen存消息的媒介当然是通过Message对象啦，那这个Message对象又是什么呢？
其实这个Message就是用来存储Message中各种信息的Bean对象，从源码中可以其属性，这里例举我们常用的几个
public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
int flags;
long when;
Bundle data;
Handler target;
Runnable callback;
Handler源码分析
一、Handler的创建
Handler的创建会关联一个Looper对象，而Looper对象是关联着MessageQueen对象，所以在Handler创建时候，取出Looper和MessageQueen
public Handler(Callback callback, boolean async) {
...
//取出Looper
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//取出Looper中的MessageQueen
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
前面我们也说过了Looper是存放在ThreadLocal里面的，可以看到下面的源码就知道了
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
整个创建的过程就完了，这里做了哪几件事：
取出Looper
取出Looper中的MessageQueen
二、Handler发送消息
1、方式一：sendMessage(Message msg)
//从这里开始
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
//往下追踪
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
//往下追踪
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
//往下追踪
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
//直接获取MessageQueue
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
//调用sendMessage方法其实最后是调用了enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//为msg.target赋值为this，也就是把当前的handler作为msg的target属性
//如果大家还记得Looper的loop()方法会取出每个msg然后执行msg.target.dispatchMessage(msg)去处理消息，其实就是派发给相应的Handler
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//最终调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去
return queue.enqueueMessage(msg, uptimeMillis);
}
2、方式二：post(Ruunable r)
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
其实post()方法最终也会保存到消息队列中去，和上面不同的是它传进来的一个Runnable对象，执行了getPostMessage()方法，我们往下追踪
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
实质上就是将这个Runnable保存在Message的变量中，这就导致了我们下面处理消息的时候有两种不同方案
三、Handler处理消息
你还记得前面所说Looper中msg.target.dispatchMessage()方法吗？这个方法就是调用Handler的dispatchMessage()
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
//1. post()方法的处理方法
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//2. sendMessage()方法的处理方法
handleMessage(msg);
}
}
//1. post()方法的最终处理方法
private static void handleCallback(Message message) {
message.callback.run();
}
//2. sendMessage()方法的最终处理方法
public void handleMessage(Message msg) {
}
整个处理的过程就完了，这里做了哪几件事：
post()方法的处理方法就是将传进来的Runnable执行run()方法
sendMessage()方法的处理方法就是执行handleMessage()空方法，这也是我们为什么要在Handler重写这个方法的原因
参考：https://blog.csdn.net/qq_30379689/article/details/53394061
扫一扫
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
