第10章 Android的消息机制

文章目录

        • 1. 前因
        • 2. 工作原理
        • 3. ThreadLocal
        • 3. 消息队列MessageQueue
        • 4. Looper
        • 5. Handler
        • 6. 主线程的消息循环
        • 7. 使用示例
        • 8. 其他

1. 前因

Handler的主要作用是讲一个任务切换到某个指定的线程中工作,主要用于更新UI,因为Android规定访问UI只能在主线程中进行(Android的UI控件不是线程安全的,上锁机制会让UI的访问逻辑复杂,且锁机制会降低UI访问效率,所以最简单高效的方法就是用单线程模型来处理UI操作)。

2. 工作原理

Handler创建时会采用当前线程的Looper来构建内部的消息循环系统。

通过Handler的post方法将一个Runnable或通过send方法发一个消息到Looper中,post方法最终也是调到send,send方法调用MessageQueue的enqueueMessage方法将消息放入消息队列,然后Looper发现会进行处理,最终消息中的Runnable或者Handler的handleMessage会被调用,由于Looper是运行在创建Handler所在的线程中的,这样Handler中的业务逻辑就被切换到创建Handler的线程中去执行了。

3. ThreadLocal

ThreadLocal 是一个线程内部的数据存储类,通过它可以再指定的线程中存储数据,Looper、ActivityThread、AMS中都有用到。有 set 和 get 方法

使用场景分析:

1)对于Handler来说,它需要获取当前线程的looper,显然Looper的作用域就是线程并且不同的线程有不同的Looper,这时就可以使用ThreadLocal实现Looper在线程中的存取。

2)复杂逻辑下的对象传递,比如监听器的传递,采用ThreadLocal可以让监听器作为线程内的全局对象而存在。

3. 消息队列MessageQueue

是一个单链表

1)插入 enqueueMessage,单链表的插入

2)读取并删除 next,是一个无限循环的方法,如果消息队列中没有消息,next方法会一直阻塞在这里,当新消息到来时,next方法会返回这条消息并将其从单链表中移除

3)这里创建Message对象的时候,有三种方式:

Message msg1 = new Message();	// 就是直接初始化一个Message对象
Message msg2 = Message.obtain();
Message msg3 = handler.obtainMessage();

2、3种方式一样,从整个Messge池中返回一个新的Message实例,Messge池为空才创建新的对象,能避免重复Message创建对象,源码:

/**
     * Return a new Message instance from the global pool. Allows us to
     * avoid allocating new objects in many cases.
     */
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

4. Looper

不停的从MessageQueue中查看是否有新消息,如果有立刻处理,否则阻塞在那里。

1)构造方法:创建一个MessageQueue;将当前线程的对象保存起来

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

2)创建Looper:Looper.prepare()为当前线程创建一个Looper,Looper.loop() 开启消息循环

new Thread("123") {
        @Override
        public void run() {
            super.run();
            Looper.prepare();
            Handler handler = new Handler();
            Looper.loop();
        };
    }.start();

3)Looper.getMainLooper() 获取主线程Looper

4)退出:quit 和 quitSafely

quit直接退出,quitSafely设定一个退出标记,等消息队列中已有的消息处理完毕后退出。

Looper退出后,Handler发送消息会失败,send返回false。

子线程如果手动创建Looper在所有事情完成后记得用quit终止循环,退出Looper后,这个线程也立即终止。

5)loop方法:死循环,唯一跳出循环的方式是MessageQueue的next方法返回null

Looper的quit方法调用,会调用MessageQueue的quit或quitSafely方法通知消息队列退出,此时next返回null

6)loop 方法调用MessageQueue的next方法获取新消息,而next是一个阻塞操作,当没有消息时,next会一直阻塞在那里,导致loop也一直阻塞在那里;如果MessageQueue的next返回了新消息,Looper就会处理这条消息:

msg.target.dispatchMessage(msg),这里的msg.target 是发送这条消息的Handler对象,这样Handler发送的消息最终又交给它的dispatchMessage来处理了,注意,Handler的dispatchMessage方法是在创建 Handler时所使用的Looper中执行的,这样就成功将代码逻辑切换到指定的线程中去执行了。

5. Handler

发送消息和接收

1)发送通过post或者send,post最终也是通过send,发送消息的过程就是向消息队列中插入一条消息,MessageQueue的next方法会将这条消息给Looper

2)Looper收到消息后开始处理,最终交由Handler

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

首先检查 Message的callback是否为null,不为bukk就通过handleCallback 来处理消息,Message的callback 是一个 Runnable 对象,实际上就是Handler 的 post方法所传递的Runnable参数

private static void handleCallback(Message message) {
        message.callback.run();
    }

其次检查mCallback 是否为null,不为null就调用 mCallback 的 handleMessage 方法。

Callback 是一个接口,可以用来创建一个Handler的实例但不需要派生Handler的子类

Handler handler = new Handler(callback);

最后调用Handler 的 handleMessage 方法来处理消息。

3)Handler 还可以通过一个Looper来构造

public Handler(Looper looper) {
        this(looper, null, false);
}

6. 主线程的消息循环

Activity 的 主线程就是 ActivityThread,入口为main,main方法中系统通过 Looper.prepareMainLooper() 来创建主线程的 Looper 以及 MessageQueue,并通过 Looper.loop() 来开启主线程的消息循环

ActivityThread.H 是其Handler,定义了一组消息类型,包含了四大组件的启动和停止等过程

ActivityThread 通过 ApplicationThread 和 AMS 进行进程间通信,AMS 以进程间通信的方式完成 ActivityThread 的请求后会回调 ApplicationThread 中的Binder方法,然后 ApplicationThread 会向 H发送消息,H收到消息后会将 ApplicationThread 中的逻辑切换到 ActivityThread中去执行,即切换到主线程中去执行,这个过程就是主线程的消息循环模型

7. 使用示例

1)在主线程创建

    // 方法1 使用内部类方式创建Handler
    class mHandler extends Handler {

        // 复写handlerMessage() 
        @Override
        public void handleMessage(Message msg) {
         ...// 需执行的UI操作
            
        }
    }   
    
    // 方法2 使用匿名内部类创建Handler
    Handler handler = new Handler(){
    
    		// 复写handlerMessage() 
        @Override
        public void handleMessage(Message msg) {
            //msg就是子线程发送过来的消息。
        }
    };

    //开启一个子线程 发消息方式1
    new Thread(new Runnable() {
            @Override
            public void run() {
                //在子线程发送一个消息。
                Message msg = new Message();
                handler.sendMessage(msg);
            }
        }).start();
   
   //开启一个子线程 发消息方式2
    new Thread(new Runnable() {
            @Override
            public void run() {
                //在子线程post一个Runnable对象
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        //这里是消息处理的方法
                        //这里运行在主线程。
                    }
                });
            }
        }).start();

注意:Handler的内存泄漏

as不建议我们用上述方式生成Handler,这是应为非静态内部类会持有外部内的引用。那么Handler将会持有Activity的引用,我们知道handler是会被msg.target持有的,而msg又在MessageQueue队列中,那么当消息队列中拥有未消费的Message时,会导致Activity即使finish了也无法被GC回收,最终导致内存泄漏。为了避免这个问题我们可以将Handler写成外部类或者静态的内部类,并且传递的Activity引用可以用WeakReference弱引用来持有,同时可以在Activity的onDestory中使用Handler.removeCallbacksAndMessages(null);来清空消息队列

2)在子线程创建方式1 使用子线程的Looper 消息处理在子线程

    // 声明Handler
    Handler handler;
    new Thread(new Runnable() {
        @Override
        public void run() {
        // 创建当前线程的Looper
            Looper.prepare();
            // 在子线程创建handler对象
            handler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                // 这里是消息处理,它是运行在子线程的
                }
           };
           // 开启Looper的消息轮询
           Looper.loop();
       }
   }).start();

   mBanner.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View v) {
       		 // 在主线程发送一个消息到子线程
           Message msg = new Message();
           handler.sendMessage(msg);
       }
   });

3)在子线程创建方式2 使用主线程的Looper 消息处理在主线程

    new Thread(new Runnable() {
        @Override
        public void run() {
            // 获取主线程的Looper
            Looper looper = Looper.getMainLooper();
            // 用主线程的Looper创建Handler
            handler = new Handler(looper) {
                @Override
                public void handleMessage(Message msg) {
                // 这里是运行在主线程的
                }
            };
        }
    }).start();

4)使用 Callback接口

public class MyClass implements Handler.Callback {
		...
		private Handler handler;
		
		// 主线程的Looper
		handler = new Handler(Looper.getMainLooper(), this);
		
		// 子线程的Looper
		HandlerThread handlerThread = new HandlerThread("subthread");
    handlerThread.start();
    handler = new Handler(handlerThread.getLooper(), this);
    
		@Override
    public boolean handleMessage(Message msg) {
        ...
    }
}

8. 其他

**1)Android已经提供了很多实现了Handler的类和方法,方便我们使用。**如Activity类的runOnUiThread()方法,View的post()方法,HandlerThread类等,关于这些知识,有待补充

  • runOnUiThread
public final void runOnUiThread(Runnable action) {
    if (Thread.currentThread() != mUiThread) {
        mHandler.post(action);
    } else {
        action.run();
    }
}
  • postInvalidate底层是使用了Handler,向主线程发消息更新UI

  • HandlerThread 是Android API提供的一个方便、便捷的类,使用它我们可以快速的创建一个带有Looper的线程。Looper可以用来创建Handler实例

2)Android中为什么主线程不会因为Looper.loop()里的死循环卡死

3)一个线程只能有一个Looper

public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

本文参考:

《Android开发艺术探索》第十章

https://juejin.im/post/5910533dac502e006cfe01cd

你可能感兴趣的:(Android)