Handler机制源码之路(四)Handler篇

Handler 基础了解

1. Handler 是干嘛的

说白了，Handler 就是 Android 提供的 线程之间交互 的一种方式，并在系统层面同样大量使用。

2. Handler 的工作流程是怎样的

当每个线程创建时，可选择 为该线程创建自己的循环队列 (Looper + MessageQueue) ，当 [线程B] 想发送消息给 [线程A] 时，只需要在 [线程B] 把消息推送到 [线程A] 的 MessageQueue 中，[线程A] 就可以用 Looper 提取 MessageQueue 中的 Message 了

3. 系统有哪些地方使用了 Handler

  • CountDownTimer
  • Messenger
  • AsyncTask
  • IntentService
  • View
  • LocalBroadcast
  • 等

4. Handler 机制所使用的主要类

  • Message
  • MessageQueue
  • Looper
  • Handler

5. Handler 的基础使用方法

// 1.在需要接受数据的线程创建Handler
Handler handler = new Handler(){
    @Override
   public void handleMessage(Message msg) {
        // 4.这里接收发送的数据
   }
}
// 2.在需要发送数据的线程创建Message
Message message = Message.obtain();__
// 3.调用接收线程的handler发送消息
handler.sendMessage(message);

主要类源码分析

1. Message

Handler机制源码之路(一)Message篇

2. MessageQueue

Handler机制源码之路(二)MessageQueue篇

3. Looper

Handler机制源码之路(三)Looper篇

4. Handler

其实 Handler 的大部分功能都是来自于Message、MessageQueue 和 Looper 的，这是一种组合和聚合的设计模式，使得使用者只需要关注 Handler 的使用方法，也无法破坏内部的实现逻辑。

4.1 继承关系

// 无继承、无实现
public class Handler {

4.2 内部接口

public interface Callback {
    public boolean handleMessage(Message msg);
}

那么这个接口的作用是什么呢，在接下来的代码分析中会说到，这里总结一下就是，他可以拦截 Handler 本身的 handlerMessage() 方法。

4.3 变量

private static final boolean FIND_POTENTIAL_LEAKS = false;// 检查泄露使用的标志
private static final String TAG = "Handler";
private static Handler MAIN_THREAD_HANDLER = null;// 主线程Handler的引用
final Looper mLooper;// 当前线程Looper
final MessageQueue mQueue;// 当前Looper对应的MessageQueue
final Callback mCallback;// 拦截回调
final boolean mAsynchronous;// 消息异步标识
IMessenger mMessenger;// aidl类

4.4 构造方法

构造方法有很多，但是最终只会调用到两个具体实现上。

  • public Handler(Callback, boolean)
// 该方法为隐藏方法，只能内部调用
public Handler(Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {// 检查泄露，但目前看来flag写死未false，不知道是不是为了系统开发准备的
        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());
        }
    }
    // 获取当前Looper
    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 Handler(Looper, Callback, boolean)

这个方法是外部构造 Handler 最主要的实现方法，虽然他内部只是简单的赋值，但这部操作实际上决定了 Handler 发送消息的线程！发送消息的线程即为 mLooper 所在的线程。

public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}
  • public Handler(Callback)
  • public Handler(boolean)
  • public Handler(Looper)
  • public Handler(Looper, Callback)

4.5 Handler 的静态创建 createAsync() 方法

该方法主要用于创建异步的 Handler，而异步的 Handler 在 MessageQueue 的源码分析中我们已经知道，不会受到消息屏障的阻塞。

@NonNull
public static Handler createAsync(@NonNull Looper looper) {
    if (looper == null) throw new NullPointerException("looper must not be null");
    return new Handler(looper, null, true);
}

@NonNull
public static Handler createAsync(@NonNull Looper looper, @NonNull Callback callback) {
    if (looper == null) throw new NullPointerException("looper must not be null");
    if (callback == null) throw new NullPointerException("callback must not be null");
    return new Handler(looper, callback, true);
}

4.6 Hanlder 的 dispatchMessage() 和 handleMessage() 方法

// 该方法在Looper的loop()方法循环被调用
public void dispatchMessage(Message msg) {
    //先判断msg的callback
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        // 再判断Handler的callback
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 最后调用Handler自身的handleMessage
        handleMessage(msg);
    }
}
// 空方法，需复写它实现自己IDE逻辑
public void handleMessage(Message msg) {
}

4.7 Handler 的 obtainMessage() 方法

obtainMessage() 方法其实就是调用了 Message.obtain() 方法

  • obtainMessage()
  • obtainMessage(int)
  • obtainMessage(int, int, int)
  • obtainMessage(int, int, int, Object)
  • obtainMessage(Object)
  • getPostMessage(Runnable)
  • getPostMessage(Runnable, Object)

4.8 Handler 的 hasMessage() 方法

hasMessage() 方法其实就是调用了 MessageQueue.hasMessage() 方法

  • hasMessage()
  • hasMessage(int)
  • hasMessageAndObejct(int, Object)

4.9 Handler 的 removeMessages() 方法

removeMessages() 方法其实就是调用了 MessageQueue.removeMessages()

  • removeMessage(int)
  • removeMessage(int, Object)
  • removeCallbacks(Runnable)
  • removeCallbacks(Runnable, Object)
  • removeCallbacksAndMessages(Object)

4.10 Handler 的 enqueueMessage() 方法

该方法为向消息队列中添加消息的最终入口。

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {// 可以看到，消息的异步属性跟消息所在的Handler是一样的
        msg.setAsynchronous(true);
    }
    // 调用MessageQueue的方法
    return queue.enqueueMessage(msg, uptimeMillis);
}

4.11 Handler 的 send/post 方法

sendMessage 的一系列方法用于向消息队列中插入 Message。其实就是封装后再调用 enqueueMessage()。

4.11.1 sendMessage() 方法
public final boolean sendMessage(Message msg) {
    return sendMessageDelayed(msg, 0);
}

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

public final boolean sendMessageAtFrontOfQueue(Message msg) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
            this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    // 当uptimeMillis为0时，即为最优先执行
    return enqueueMessage(queue, msg, 0);
}
// 判断当前Looper直接执行分发
public final boolean executeOrSendMessage(Message msg) {
    if (mLooper == Looper.myLooper()) {
        dispatchMessage(msg);
        return true;
    }
    return sendMessage(msg);
}
4.11.3 sendEmptyMessage() 方法

可以看到 sendEmptyMessage() 最终都会调到 sendMessage()

public final boolean sendEmptyMessage(int what) {
    // 延时为0
    return sendEmptyMessageDelayed(what, 0);
}

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    // 通过复用得到Message
    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);
}
4.11.3 post() 方法

post() 最终也是拼装成 Message，然后调用 sendMessage()。

public final boolean post(Runnable r) {
   return  sendMessageDelayed(getPostMessage(r), 0);
}

public final boolean postAtTime(Runnable r, long uptimeMillis) {
    return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}

public final boolean postAtTime(Runnable r, Object token, long uptimeMillis) {
    return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}

public final boolean postDelayed(Runnable r, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}
    
public final boolean postDelayed(Runnable r, Object token, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r, token), delayMillis);
}
    
public final boolean postAtFrontOfQueue(Runnable r) {
    return sendMessageAtFrontOfQueue(getPostMessage(r));
}

4.12 Handler 的进程间通信

IMessenger 为 AIDL 接口,可以看到Handler的跨进程通信依旧是使用Binder机制

final IMessenger getIMessenger() {
    synchronized (mQueue) {
        if (mMessenger != null) {
            return mMessenger;
        }
        mMessenger = new MessengerImpl();
        return mMessenger;
    }
}

private final class MessengerImpl extends IMessenger.Stub {
    public void send(Message msg) {
        msg.sendingUid = Binder.getCallingUid();
        Handler.this.sendMessage(msg);
    }
}

4.13 Handler 的阻塞任务

同步运行指定的任务。

如果当前线程与处理程序线程相同，那么runnable将立即运行，而不会排队。否则，将runnable发布到处理程序，并等待它完成后再返回。

这种方法很危险！使用不当会导致死锁。不要在持有任何锁时调用此方法，也不要以可能重新进入的方式使用它。

在后台线程必须同步等待必须在处理程序线程上运行的任务完成的情况下，此方法有时很有用。然而，这个问题通常是不良设计的一个症状。在采用这种方法之前，考虑改进设计（如果可能的话）。

您可能希望使用此方法的一个示例是，当您刚刚设置了一个处理程序线程，并且需要在继续执行之前对其执行一些初始化步骤时。

如果发生超时，则此方法返回false，但可运行文件将保留在处理程序上，并且可能已在进行中或稍后完成。

使用此方法时，请确保在退出Looper时使用Looper.QuitSafely。否则，用剪刀跑步可能会无限期地挂起来。（TODO:我们应该通过让messagequeue知道阻塞可运行文件来解决这个问题。）

public final boolean runWithScissors(final Runnable r, long timeout) {
    if (r == null) {
        throw new IllegalArgumentException("runnable must not be null");
    }
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout must be non-negative");
    }

    if (Looper.myLooper() == mLooper) {
        r.run();
        return true;
    }

    BlockingRunnable br = new BlockingRunnable(r);
    return br.postAndWait(this, timeout);
}

private static final class BlockingRunnable implements Runnable {
    private final Runnable mTask;
    private boolean mDone;

    public BlockingRunnable(Runnable task) {
        mTask = task;
    }

    @Override
    public void run() {
        try {
            mTask.run();
        } finally {
            synchronized (this) {
                mDone = true;
                notifyAll();
            }
        }
    }

    public boolean postAndWait(Handler handler, long timeout) {
        if (!handler.post(this)) {
            return false;
        }

        synchronized (this) {
            if (timeout > 0) {
                final long expirationTime = SystemClock.uptimeMillis() + timeout;
                while (!mDone) {
                    long delay = expirationTime - SystemClock.uptimeMillis();
                    if (delay <= 0) {
                        return false; // timeout
                    }
                    try {
                        wait(delay);
                    } catch (InterruptedException ex) {
                    }
                }
            } else {
                while (!mDone) {
                    try {
                        wait();
                    } catch (InterruptedException ex) {
                    }
                }
            }
        }
        return true;
    }
}

4.14 总结

通关源码的查看，确实可以看到，Handler 实现了对 Looper 以及 MessageQueue 和 Message 的封装，并在此基础上，实现了一个 IMessenger 的 AIDL 接口，从而保证 Handler 可以在进程间传递 Message 消息。

Handler应用类拓展阅读

1.CountDownTimer

Handler机制应用之CountDownTimer篇

Q&A

  • 如何进行跨线程通信的
  • 如何使用Handler进行跨进程通信
  • Looper可不可以不借助Handler使用
  • MessageQueue可不可以不借助Looper使用
  • 在Handler的使用中Looper是什么时候创建的
  • MessageQueue是什么时候创建的
  • Message的复用队列是什么创建的
  • Handler为什么要声明成静态
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。