Android的消息机制 Handler、MessageQueue、ThreadLocal、Looper

来来走走

已于 2024-03-06 22:47:29 修改

阅读量2.6k

点赞数

分类专栏： Android

于 2022-02-28 15:25:11 首次发布

本文链接：https://blog.csdn.net/u011609853/article/details/123159223

版权

android java

Android 专栏收录该内容

70 篇文章 0 订阅

订阅专栏

handler的作用：
具体来说，有时候需要执行一个比较耗时的工作，在主线程执行是非常不友好的，于是我们从子线程中去执行，可能是读取文件也可能是网络请求。当子线程中的工作完成以后可能需要在页面上显示信息，但在Android的规则中，不能在子线程中更新ui，这个时候就可以通过handler切换到主线程中进行ui操作。简单的说，将一个任务切换到某个指定的线程中去执行。

Android的消息机制主要是指Handler的运行机制，Handler的运行需要MessageQueue和looper的支撑。MessageQueue的中文名称叫消息队列，但是MessageQueue的内部实现不是真正的队列，本质上是单链表（数据结构）。Looper中文名称叫循环，会循环的查找MessageQueue中是否有消息，有的话就去执行，没有则等待。Looper中有ThreadLocal，作用是在每个线程中存储数据。

Handler创建时会采用当前线程的Looper来构造消息循环系统，问：Handler内部如何获取到当前线程的Looper？
答：ThreadLocal可以在不同的线程中存储并提供数据，且各个线程的数据互不干扰。通过ThreadLocal获取每个线程looper。

问:为什么可以在主线程中使用Handler？
答：主线程是ActivityThread，ActivityThread被创建时就会初始化Looper。

ThreadLocal的工作原理

ThreadLocal是一个线程内部的数据存储类，能够从指定的线程中获取相应的数据，对于其他线程来说无法获取不是自己的数据。
使用场景，当某些数据是以线程为作用域并且不同线程具有不同的数据副本时，可考虑使用ThreadLocal。还有一种使用场景，复杂逻辑对象下的对象传递，如下。

监听器传递的场景，一个线程中函数调用栈比较深以及代码入口的多样性，还要监听器能够贯穿整个线程。这情况使用ThreadLocal可以让监听器作为线程内的全局对象，通过get方法就可以获取到监听器。
如果不使用ThreadLocal，第一种是将监听器通过参数的方式在函数调用中进行传递。第二种则是将监听器作为静态变量供线程访问。第一种方法的问题是当调佣栈很深的时候，通过参数来传递监听器对象是非常不友好的，不是一个好的程序设计。第二种方法的问题是不具有可扩充性，如同时有两个线程执行，就需要提供两个静态的监听器对象，多个线程就需要提供多个静态的监听器。

下面通过代码来熟悉ThreadLocal。

		ThreadLocal<Boolean> booleanThreadLocal = new ThreadLocal<>();

        new Thread("Thread#0") {
            @Override
            public void run() {

                booleanThreadLocal.set(true);
                Log.d("ThreadLocal", Thread.currentThread().getName() + ",booleanThreadLocal:" + booleanThreadLocal.get() + "");
            }
        }.start();

        new Thread("Thread#1") {
            @Override
            public void run() {

                booleanThreadLocal.set(false);
                Log.d("ThreadLocal", Thread.currentThread().getName() + ",booleanThreadLocal:" + booleanThreadLocal.get() + "");
            }
        }.start();

        new Thread("Thread#2") {
            @Override
            public void run() {

                Log.d("ThreadLocal", Thread.currentThread().getName() + ",booleanThreadLocal:" + booleanThreadLocal.get() + "");
            }
        }.start();

结果如下

2022-02-27 18:15:15.417 6191-6230/cn.study.study20220109 D/ThreadLocal: Thread#0,booleanThreadLocal:true
2022-02-27 18:15:15.418 6191-6231/cn.study.study20220109 D/ThreadLocal: Thread#1,booleanThreadLocal:false
2022-02-27 18:15:15.421 6191-6232/cn.study.study20220109 D/ThreadLocal: Thread#2,booleanThreadLocal:null

上面的代码主要体现了在不同的线程中，取到的值也是不同的。

ThreadLocal为何能够在不同的线程中获取的值不一样，因为不同的线程访问同一个ThreadLocal的get方法，ThreadLocal内部会从各自的线程中取出一个数组，从数组中根据当前ThreadLocal的索引去查找对应的value值。由于Android系统的升级，部分代码可能发生了改变，在新的代码中通过get方法获取数据，取出的是ThreadLocalMap，ThreadLocalMap有Entry数组，从数组中获取Entry，在Entry中获取value。

消息队列的了解

MessageQueue主要包含两个操作：插入和读取。插入和读取对应的方法是enqueueMessage和next，enqueueMessage的作用是往消息队列中插入一条消息，next的作用是从消息队列中取出一条消息并将其从消息队列中移除。说明一下next方法是一个无限循环的方法，如果MessageQueue中有消息则执行，没有则处于等待状态，会阻塞。

Looper的工作原理

Looper会不停地从MessageQueue中查看是否有新消息，如有新的消息会立即处理，没有消息则会一直阻塞。

如何为一个线程提供Looper，代码如下：

  new Thread("thread#3") {

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

说明一下Looper中的几个方法，quit与quitSafely方法的作用是退出Looper，二者的区别是：quit会直接退出Looper，quitSafely是提出退出的意图，直到消息队列中的已有消息全部处理完毕才退出。就上面的在一个线程中提供Looper也是需要通过quit来退出的，否则这个线程会一直处于等待的状态。

Handler的工作原理

Handler的工作主要包含消息的发送和接收过程。其中post的一系列方法最终通过send的一系列方法来实现。具体代码：

public final boolean sendMessage(@NonNull Message msg) {
        return sendMessageDelayed(msg, 0);
    }

    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 sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }

    public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

    public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
        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);
    }
    
    private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

通过源码发现，Handler发送消息的过程只是向消息队列中插入一条消息。消息会由Looper传递给Handler进行处理，Handler的dispatchMessage方法被调用。dispatchMessage源码如下：

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

上面的代码很简单，只说一下关键点，Message 的callback是一个Runnable对象，实际上就是Handler的post方法所传递Runnable参数。mCallback 是一个接口。

Handler handler1 = new Handler(callback);

Callback的意义是创建一个Handler的实例但不需要派生Handler的子类。

主线程的消息循环

Android的主线程是ActivityThread，主线程的入口方法为main，通过Looper.prepareMainLooper()来创建主线程的Looper和Message，通过Looper.loop()来开启主线程的消息循环。看到这里是你是否会想起给一个线程中的handler提供looper的例子，非常相似。

   public static void main(String[] args) {
        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");

        // Install selective syscall interception
        AndroidOs.install();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Make sure TrustedCertificateStore looks in the right place for CA certificates
        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        // Call per-process mainline module initialization.
        initializeMainlineModules();

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();

        // Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
        // It will be in the format "seq=114"
        long startSeq = 0;
        if (args != null) {
            for (int i = args.length - 1; i >= 0; --i) {
                if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
                    startSeq = Long.parseLong(
                            args[i].substring(PROC_START_SEQ_IDENT.length()));
                }
            }
        }
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        // End of event ActivityThreadMain.
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }