【Android 开发】: Android 消息处理机制之四: Android 消息循环 Looper 及其源码解析
16lz
2021-01-23
相关连接： Android 消息处理机制之一: Handler 与 Message
Android 消息处理机制之二: Message 中 obtain()源代码剖析
Android 消息处理机制之三: Handler 中 sendMessage() 源代码剖析
上一讲我们学习Handler和Message的一些使用方式，我们知道Handler它会发送消息和处理消息，并且关联一个子线程，如何发送消息入队和出队处理消息等这些都是交给Looper去管理分发的，也就是它是负责整个消息队列运转的一个类，这一讲我们就来学习一下Android中的Looper的操作。
一、Looper类介绍
这个类是用来在一个线程中运行一个消息循环(Message)，默认情况下线程是没有一个消息循环来关联它们的，在这个线程中调用prepare()方法来启动一个循环，然后调用loop()就可以处理消息至到循环停止。下面就是一个典型的例子实现一个Looper线程，使用 prepare()方法 和 loop()来创建一个初始的Handler并且能够与消息循环(Looper)进行沟通关联
【注意】:默认情况下的android新诞生的一个线程是没有开启一个消息循环(Looper)的，但是主线程除外，主线程系统会自动为其创建Looper对象，开启消息循环。
二、程序Demo
1. 布局文件定义一个Button和TextView,这里不贴出来,读者可以阅读附件源码
2. MainActivity.java
...public class MainActivity extends Activity { private Button btn; private TextView txt; private MyHandler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ... mHandler = new MyHandler(); btn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub // 启动线程 new Thread(new MyThread()).start(); } }); } public class MyThread implements Runnable { @Override public void run() { // TODO Auto-generated method stub Message msg = Message.obtain(); msg.obj = "AHuier"; mHandler.sendMessage(msg); } } public class MyHandler extends Handler { public MyHandler() { super(); // TODO Auto-generated constructor stub } // Handler中有个传递Looper对象的构造方法,这个构造方法比较少用 public MyHandler(Looper looper) { super(looper); // TODO Auto-generated constructor stub } @Override public void handleMessage(Message msg) { // TODO Auto-generated method stub super.handleMessage(msg); txt.setText("接受子线程发送的消息 --->" + msg.obj); } }...}3. 程序执行结果
4. 【说明】: 在上面的代码中我们并没有去手动生成Looper对象，主线程依然可以完成接受子线程消息并显示的操作，在这里我们需要明白为什么我们之前的例子中虽然没有创建一个Looper去管理消息，但是子线程中发送消息依然能够被主线程接受到，原因是因为我们主线程中已经存在了默认的一个Looper对象。
这里我们在做一个小测试,我们给其生成一个Looper对象,在onCreate()方法中添加代码如下：
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); initComponent(); // 在Activity中有一个默认的Looper对象,来处理子线程发送的消息 // 这里我们尝试的给其生成一个Looper对象,也是可以的 Looper looper = Looper.myLooper(); //获得与子线程关联的Looper对象 mHandler = new MyHandler(looper); btn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub // 启动线程 new Thread(new MyThread()).start(); } }); }程序执行依然会接受到子线程发送的消息。为什么会是这样的呢？我们来查看一下它们的源码1) 查看Handler源码中的构造方法
/** * Default constructor associates this handler with the queue for the * current thread. * * If there isn't one, this handler won't be able to receive messages. */ public Handler() { if (FIND_POTENTIAL_LEAKS) { final Class<? extends Handler> klass = getClass(); if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && (klass.getModifiers() & Modifier.STATIC) == 0) { Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName()); } } mLooper = Looper.myLooper(); if (mLooper == null) { throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare()"); } mQueue = mLooper.mQueue; mCallback = null; }可以发现在其构造方法中就已经默认为帮其生成一个Looper对象了: mLooper = Looper.myLooper();
同时从Looper中获取到一个消息队列，并且赋值给Handler的本地的mQueque,我们在看一下Handler(Looper looper)这个构造方法如下：/** * Use the provided queue instead of the default one. */ public Handler(Looper looper) { mLooper = looper; mQueue = looper.mQueue; mCallback = null; }同样也是接受用户生成的一个Looper对象。所以是底层实现方式都是一模一样了,从这里我们也知道了为什么默认情况下主线程都会默认的Looper对象去维护了。2) 这里我们需要在看一下为什么会调用 Looper.myLooper();会获取到一个Looper对象,跟踪其源码如下：
/** * Return the Looper object associated with the current thread. Returns * null if the calling thread is not associated with a Looper. */ public static Looper myLooper() { return sThreadLocal.get(); }继续跟踪是谁给其sThreadLocal实例化// sThreadLocal.get() will return null unless you've called prepare(). static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();sThreadLocal 是从一个本地线程中获取Looper类型的本地线程ThreadLocal对象，这里只需要明白ThreadLocal是一个Android提供管理线程的一个东西。/** Initialize the current thread as a looper. * This gives you a chance to create handlers that then reference * this looper, before actually starting the loop. Be sure to call * {@link #loop()} after calling this method, and end it by calling * {@link #quit()}. */ public static void prepare() { if (sThreadLocal.get() != null) { throw new RuntimeException("Only one Looper may be created per thread"); } sThreadLocal.set(new Looper()); }在prepare()方法中,会从sThreadLocal通过get获取一个本地线程的对象, 如果是空的话,这个东西中将new出来的Looper对象set到本地线程中。查看ThreadLocal的get和set方法public T get() { // Optimized for the fast path. Thread currentThread = Thread.currentThread(); Values values = values(currentThread); if (values != null) { Object[] table = values.table; int index = hash & values.mask; if (this.reference == table[index]) { return (T) table[index + 1]; } } else { values = initializeValues(currentThread); } return (T) values.getAfterMiss(this); }public void set(T value) { Thread currentThread = Thread.currentThread(); Values values = values(currentThread); if (values == null) { values = initializeValues(currentThread); } values.put(this, value); }也就是说它终究是通过set的方式讲new出来的Looper对象扔到ThreadLocal中,由它来完成初始化和关联一个线程,如果要得到一个Looper对象就从ThreadLocal中get出来。通过这种方式来关联和初始化指定线程的Looper对象。
5. 在上面的一个Demo中,我们是实现了子线程发送消息给主线程来更新UI的操作和Looper的关系,子线程默认情况下是没有Looper的对象的,下面我就来测试一下主线程向子线程发送消息,由于子线程默认没有Looper,我们就来测试一下这样实现会发生什么情况？[注意,这种方式我们一般在实际开发中是很少见的],Demo2如下所示：
1) MainActivity.java 中贴出onCreate()和 MyThread 类里面的代码段,读者可以阅读附件中的源代码
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); initComponent(); new Thread(new MyThread()).start(); btn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub // 点击按钮的时候在UI主线程中向子线程发送消息 Message message = Message.obtain(); message.obj = "AHuier"; mHandler.sendMessage(message); } }); } public class MyThread implements Runnable { @Override public void run() { mHandler = new Handler(){ @Override public void handleMessage(Message msg) { // TODO Auto-generated method stub super.handleMessage(msg); // 由于不能在子线程中更新UI,所以我们输出到控制台. System.out.println("接受主线程中发出来的消息" + msg.obj); } }; } }编译执行发出异常:
从这里我们可以得出结论在子线程中,默认情况下是没有Looper对象的,所以我们需要根据博文上面的Looper类的说明添加prepare()方法 和 loop()方法来启动Looper消息循环。修改程序如下2)
2) 在MyThread子线程中添加prepare()方法 和 loop()方法完成Looper消息循环的启动
public class MyThread implements Runnable { @Override public void run() { Looper.prepare(); mHandler = new Handler(){ @Override public void handleMessage(Message msg) { // TODO Auto-generated method stub super.handleMessage(msg); // 由于不能在子线程中更新UI,所以我们输出到控制台. System.out.println("接受主线程中发出来的消息" + msg.obj); } }; Looper.loop(); } }程序执行结果：
6. 在这里为什么添加完这两个方法之后就会有Looper消息循环了？我们来查看一下Looper的相关源代码
1) prepare() 方法我们在上面已经知道,它会初始化当前的线程关联一个Looper.
2) loop()源码如下
/** * Run the message queue in this thread. Be sure to call * {@link #quit()} to end the loop. */ public static void loop() { Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } MessageQueue queue = me.mQueue; // Make sure the identity of this thread is that of the local process, // and keep track of what that identity token actually is. Binder.clearCallingIdentity(); final long ident = Binder.clearCallingIdentity(); while (true) { Message msg = queue.next(); // might block if (msg != null) { if (msg.target == null) { // No target is a magic identifier for the quit message. return; } long wallStart = 0; long threadStart = 0; // This must be in a local variable, in case a UI event sets the logger Printer logging = me.mLogging; if (logging != null) { logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what); wallStart = SystemClock.currentTimeMicro(); threadStart = SystemClock.currentThreadTimeMicro(); } msg.target.dispatchMessage(msg); if (logging != null) { long wallTime = SystemClock.currentTimeMicro() - wallStart; long threadTime = SystemClock.currentThreadTimeMicro() - threadStart; logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); if (logging instanceof Profiler) { ((Profiler) logging).profile(msg, wallStart, wallTime, threadStart, threadTime); } } // Make sure that during the course of dispatching the // identity of the thread wasn't corrupted. 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.recycle(); } } }它首先获取Looper对象,然后将消息从Looper中取出,然后赋值给MessageQueue,让MessageQueue去管理,接着在While(true)这个死循环里面一直在轮转的取消息和分发消息(从Message msg = queue.next();和msg.target.dispatchMessage(msg);)这两句代码读出。
三、总结与相关源码
通过上述两个Demo和Looper相关源码的分析,我们可以知道Looper作为一个循环机制它的作用就是初始化线程和将Handler与该线程关联的工作,以及管理,维护整个消息循环的机制。但是具体的发送消息还有处理消息都是靠Handler和Message来完成的。所以在一个新诞生的线程中,Looper都会关联到这个Thread,以及它的MessageQueue和Handler.
源码下载：
http://download.csdn.net/detail/xukunhui2/6656293
更多相关文章
- 【Android 开发】: Android 消息处理机制之一: Handler 与 Messa
- Android 对象序列化之你不知道的 Serializable
- AndroidAndroid程序提示和消息button响应事件
- Android 对象序列化之 Parcelable 取代 Serializable ?
- Android 对象序列化之追求完美的 Serial
- Android异步处理系列文章四篇之一使用Thread+Handler实现非UI线
- Android消息循环
- 你对进程线程到底理解有多少
- Android 高级进阶之深入剖析消息机制