前言

写这篇文章不是为了分析Handler怎么使用，目的是想从设计的角度来看Handler的演进过程，以及为什么会出现Looper,MessageQueue,Handler,Message这四个类。

一.线程通信的本质？

线程区别于进程的主要因素在于，线程之间是共享内存的。在android系统中，堆中的对象可以被所有线程访问。因此无论是哪种线程通信方式，考虑到性能问题，一定会选用持有对方线程的某个对象来实现通信。

1.1 AsyncTask

public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        mWorker = new WorkerRunnable() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

        mFuture = new FutureTask(mWorker) {
            @Override
            protected void done() {
                try {
                    postResultIfNotInvoked(get());
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    throw new RuntimeException("An error occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult(this, result));
        message.sendToTarget();
        return result;
    }

从用法可以看出，AsyncTask也是间接通过handler机制实现从当前线程给Looper所对应线程发送消息的，如果不传，默认选的就是主线程的Looper。

1.2 Handler

借助ThreadLocal获取thread的Looper，传输message进行通信。本质上也是持有对象线程的Looper对象。

public Handler(@Nullable Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class 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 " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }


public final boolean post(@NonNull Runnable r) {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    
  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);
    }

1.3 View.post(Runnable)

public boolean post(Runnable action) {
    final AttachInfo attachInfo = mAttachInfo;
    if (attachInfo != null) {
        return attachInfo.mHandler.post(action);
    }

    // Postpone the runnable until we know on which thread it needs to run.
    // Assume that the runnable will be successfully placed after attach.
    getRunQueue().post(action);
    return true;
}

getRunQueue().post(action)仅仅是在没有attachToWindow之前缓存了Runnable到数组中

private HandlerAction[] mActions;

public void postDelayed(Runnable action, long delayMillis) {
        final HandlerAction handlerAction = new HandlerAction(action, delayMillis);

        synchronized (this) {
            if (mActions == null) {
                mActions = new HandlerAction[4];
            }
            mActions = GrowingArrayUtils.append(mActions, mCount, handlerAction);
            mCount++;
        }
    }

等到attachToWindow时执行,因此本质上也是handler机制进行通信。

void dispatchAttachedToWindow(AttachInfo info, int visibility) {
        mAttachInfo = info;
        ....
        // Transfer all pending runnables.
        if (mRunQueue != null) {
            mRunQueue.executeActions(info.mHandler);
            mRunQueue = null;
        }
        
       .... 
        
}

1.4 runOnUiThread

public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);
        } else {
            action.run();
        }
    }

通过获取UIThread的handler来通信。

从以上分析可以看出，android系统的四种常见通信方式本质上都是通过Handler技术进行通信。

二.handler解决什么问题？

handler解决线程通信问题，以及线程切换问题。本质上还是共享内存，通过持有其他线程的Looper来发送消息。

我们常提的Handler技术通常包括以下四本部

Handler
Looper
MessageQueue
Message

三.从架构的演进来看Handler

3.1 原始的线程通信

String msg = "hello world";
Thread thread = new Thread(){
    @Override
    public void run() {
        super.run();
        System.out.println(msg);
    }
};
thread.start();

Thread thread1 = new Thread(){
    @Override
    public void run() {
        super.run();
        System.out.println(msg);
    }
};
thread1.start();

3.2 结构化数据支持

为了发送结构化数据，因此设计了Message

Message msg = new Message();
Thread thread = new Thread(){
    @Override
    public void run() {
        super.run();
        msg.content = "hello";
        System.out.println(msg);
    }
};
thread.start();

Thread thread1 = new Thread(){
    @Override
    public void run() {
        super.run();
        System.out.println(msg);
    }
};
thread1.start();

3.3 持续通信支持

Message msg = new Message();
Thread thread = new Thread(){
    @Override
    public void run() {
        for (;;){
            msg.content = "hello";
        }

    }
};
thread.start();

Thread thread1 = new Thread(){
    @Override
    public void run() {
        super.run();
        for (;;){
            System.out.println(msg.content);
        }
    }
};
thread1.start();

通过无限for循环阻塞线程，Handler中对应的是Looper。

3.4 线程切换支持

上述方法都只能是thread1接受改变，而无法通知thread。因此设计了Handler, 同时封装了发送和接受消息的方法.

class Message{
    String content = "123";
    String from = "hch";
}

abstract class Handler{
    public void sendMessage(Message message){
        handleMessage(message);
    }

    public abstract void handleMessage(Message message);
}

Message msg = new Message();
Thread thread = new Thread(){
    @Override
    public void run() {
        for (;;){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            msg.content = "hello";
            if (handler != null){
                handler.sendMessage(msg);
            }

        }

    }
};
thread.start();

Thread thread1 = new Thread(){
    @Override
    public void run() {
        super.run();
        handler = new Handler(){
            @Override
            public void handleMessage(Message message) {
                System.out.println(message.content);
            }
        };
    }
};
thread1.start();

3.5 对于线程消息吞吐量的支持

abstract class Handler{
    BlockingDeque messageQueue = new LinkedBlockingDeque<>();
    public void sendMessage(Message message){
        messageQueue.add(message);
    }

    public abstract void handleMessage(Message message);
}

...
Thread thread1 = new Thread(){
    @Override
    public void run() {
        super.run();
        handler = new Handler(){
            @Override
            public void handleMessage(Message message) {
                if (!handler.messageQueue.isEmpty()){
                    System.out.println(messageQueue.pollFirst().content);
                }

            }
        };
    }
};
thread1.start();

增加消息队列MessageQueue来缓存消息，处理线程按顺序消费。形成典型的生产者消费者模型。

3.6 对于多线程的支持

上述模型最大的不便之后在于Handler的申明和使用，通信线程双方必须能够非常方便的获取到相同的Handler。

同时考虑到使用线程的便利性，我们不能限制Handler在某个固定的地方申明。如果能够非常方便的获取到对应线程的消息队列，然后往里面塞我们的消息，那该多么美好。

因此Looper和ThreadLocal闪亮登场。

Looper抽象了无限循环的过程，并且将MessageQueue从Handler中移到Looper中。
ThreadLocal将每个线程通过ThreadLocalMap将Looper与Thread绑定，保证能够通过任意Thread获取到对应的Looper对象，进而获取到Thread所需的关键MessageQueue.

image

//ThreadLocal获取Looper
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

//Looper写入到ThreadLocal
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));
}

// 队列抽象
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

//Handler获取Looper
public Handler(@Nullable Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
        final Class 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 " + Thread.currentThread()
                    + " that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

3.7 google对于Handler的无奈妥协

思考一个问题，由于Handler可以在任意位置定义，sendMessage到对应的线程可以通过线程对应的Looper--MessageQueue来执行,那handleMessage的时候，如何能找到对应的Handler来处理呢？我们可没有好的办法能直接检索到每个消息对应的Handler

两种解决思路

通过公共总线，比如定义Map来索引，这种方式要求map必须定义到所有的线程都能方便获取到的地方，比如可以定义为static
通过消息带Message来携带属性target到对应线程，当消息被消费后，可以通过Message来获得Handler.

第一种方式的问题比较明显，公共总线需要手动维护它的生命周期，google采用的是第二种方式。

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);
}

3.8.妥协造成Handler泄露问题的根源

由于Message持有了Handler的引用，当我们通过内部类的形式定义Handler时，持有链为

Thread->MessageQueue->Message->Handler->Activity/Fragment

长生命周期的Thread持有了短生命周期的Activity.

解决方式：使用静态内部类定义Handler,静态内部类不持有外部类的引用，所以使用静态的handler不会导致activity的泄露。

四.总结

1.线程通信本质上通过共享内存来实现
2.android系统常用的四种通信方式，实际都采用Handler实现
3.Handler机制包含四部分Handler,MessageQueue,Message,Looper,它是架构演进的结果。
4.Handler泄露本质是由于长生命周期的对象Thead间接持有了短生命周期的对象造成。

最后

您的点赞收藏就是对我最大的鼓励！欢迎关注我，分享Android干货，交流Android技术。对文章有何见解，或者有何技术问题，欢迎在评论区一起留言讨论！最后给大家分享一些Android相关的视频教程，感兴趣的朋友可以去看看。

【Android源码解析】Android中高级架构进阶学习——百大框架源码解析Retrofit/OkHttp/Glide/RxJava/EventBus...._哔哩哔哩_bilibili
Android流行框架零基础入门到精通全套教程/热修复/Glide/插件化/Retrofit/OKHTTP/Gson/组件化/Jetpack/IOC/高德地图_哔哩哔哩_bilibili
Android开发进阶学习—设计思想解读开源框架 · 已更新至104集（持续更新中~）_哔哩哔哩_bilibili
【实战教学】Android开发—jetpack入门到精通_哔哩哔哩_bilibili
价值100W+Android实战项目大全/高级UI/灵动的锦鲤/QQ空间热修复/插件化框架/组件化框架设计/网络访问框架/RXJava/IOC/MVVM/NDK_哔哩哔哩_bilibili
Android音视频开发：音视频基础知识到直播推流实战系列教程_哔哩哔哩_bilibili
Android项目实战-从0开始手把手实现组件化路由SDK项目实战_哔哩哔哩_bilibili
【Android开发教程】一节课解剖Retrofit源码内核_哔哩哔哩_bilibili

本文转自 https://juejin.cn/post/7045473726929829918，如有侵权，请联系删除。

Android Handler架构思考

前言