全面解析Android进阶面试常客之Handler

2401_84123201

于 2024-04-06 12:11:25 发布

阅读量830

点赞数 27

分类专栏：程序员文章标签： android 面试职场和发展

本文链接：https://blog.csdn.net/2401_84123201/article/details/137424967

版权

程序员专栏收录该内容

462 篇文章 1 订阅

订阅专栏

什么是ThreadLocal

ThreadLocal 为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。

当使用ThreadLocal 维护变量时，ThreadLocal 为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

如果看完上面这段话还是搞不明白ThreadLocal有什么用，那么可以看下下面代码运行的结果，相信看下结果你就会明白ThreadLocal有什么作用了。

public class MainActivity extends AppCompatActivity {

private static final String TAG = “MainActivity”;

private ThreadLocal mThreadLocal = new ThreadLocal<>();

@SuppressLint(“HandlerLeak”)

private Handler mHandler = new Handler(){

@Override

public void handleMessage(Message msg) {

super.handleMessage(msg);

if (msg.what == 1) {

Log.d(TAG, "onCreate: "+mThreadLocal.get());

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

mThreadLocal.set(5);

Thread1 thread1 = new Thread1();

thread1.start();

Thread2 thread2 = new Thread2();

thread2.start();

Thread3 thread3 = new Thread3();

thread3.start();

new Thread(new Runnable() {

@Override

public void run() {

try {

Thread.sleep(2000);

mHandler.sendEmptyMessage(1);

} catch (InterruptedException e) {

e.printStackTrace();

}

}).start();

}

class Thread1 extends Thread {

@Override

public void run() {

super.run();

mThreadLocal.set(1);

Log.d(TAG, "mThreadLocal1: "+ mThreadLocal.get());

}

class Thread2 extends Thread {

@Override

public void run() {

super.run();

mThreadLocal.set(2);

Log.d(TAG, "mThreadLocal2: "+ mThreadLocal.get());

}

class Thread3 extends Thread {

@Override

public void run() {

super.run();

mThreadLocal.set(3);

Log.d(TAG, "mThreadLocal3: "+ mThreadLocal.get());

}

看下这段代码运行之后打印的log

可以看到虽然在不同的线程中对同一个mThreadLocal中的值进行了更改，但最后仍可以正确拿到当前线程中mThreadLocal中的值。由此我们可以得出结论ThreadLocal.set方法设置的值是与当前线程进行绑定了的。

知道了ThreadLocal.set方法的作用，则Looper.prepare方法就是将Looper与当前线程进行绑定（当前线程就是调用Looper.prepare方法的线程）。

文章到了这里我们可以知道以下几点信息了

在对Handler进行实例化的时候，会对一些变量进行赋值。
对Looper进行赋值是通过Looper.myLooper方法，但在调用这句代码之前必须已经调用了Looper.prepare方法。
Looper.prepare方法的作用就是将实例化的Looper与当前的线程进行绑定。

这里就又出现了一个问题：在调用Looper.myLooper方法之前必须必须已经调用了Looper.prepare方法，即在实例化Handler之前就要调用Looper.prepare方法，但是我们平常在主线程中使用Handler的时候并没有调用Looper.prepare方法呀！这是怎么回事呢？

其实，在主线程中Android系统已经帮我们调用了Looper.prepare方法，可以看下ActivityThread类中的main方法，代码如下

public static void main(String[] args) {

Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, “ActivityThreadMain”);

// 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();

// Set the reporter for event logging in libcore

EventLogger.setReporter(new EventLoggingReporter());

// Make sure TrustedCertificateStore looks in the right place for CA certificates

final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());

TrustedCertificateStore.setDefaultUserDirectory(configDir);

Process.setArgV0(“”);

Looper.prepareMainLooper();

ActivityThread thread = new ActivityThread();

thread.attach(false);

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

}

上面的代码中有一句

Looper.prepareMainLooper();

这句话的实质就是调用了Looper的prepare方法，代码如下

public static void prepareMainLooper() {

prepare(false);//这里调用了prepare方法

synchronized (Looper.class) {

if (sMainLooper != null) {

throw new IllegalStateException(“The main Looper has already been prepared.”);

}

sMainLooper = myLooper();

}

到这里就解决了，为什么我们在主线程中使用Handler之前没有调用Looper.prepare方法的问题了。

让我们再回到Handler的构造方法中，看下

mLooper = Looper.myLooper();

myLooper()方法中代码如下

/**

Return the Looper object associated with the current thread. Returns
null if the calling thread is not associated with a Looper.

public static @Nullable Looper myLooper() {

return sThreadLocal.get();

}

其实就是从当前线程中的ThreadLocal中取出Looper实例。

再看下Handler的构造方法中的

mQueue = mLooper.mQueue;

这句代码。这句代码就是拿到Looper中的mQueue这个成员变量，然后再赋值给Handler中的mQueue，下面看下Looper中的代码

final MessageQueue mQueue;

private Looper(boolean quitAllowed) {

mQueue = new MessageQueue(quitAllowed);

mThread = Thread.currentThread();

}

同过上面的代码，我们可以知道mQueue就是MessageQueue，在我们调用Looper.prepare方法时就将mQueue实例化了。

Handler的sendMessage方法都做了什么

还记得文章开始时的两个问题吗？

Handler明明是在子线程中发的消息怎么会跑到主线程中了呢？

Handler的发送消息handleMessage又是怎么接收到的呢？

下面就分析一下Handler的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);

}

/**

Enqueue a message into the message queue after all pending messages
before the absolute time (in milliseconds) uptimeMillis.
The time-base is {@link android.os.SystemClock#uptimeMillis}.
Time spent in deep sleep will add an additional delay to execution.
You will receive it in {@link #handleMessage}, in the thread attached
to this handler.
@param uptimeMillis The absolute time at which the message should be
```
    delivered, using the
```

    {@link android.os.SystemClock#uptimeMillis} time-base.

@return Returns true if the message was successfully placed in to the

    message queue.  Returns false on failure, usually because the

    looper processing the message queue is exiting.  Note that a

    result of true does not mean the message will be processed -- if

    the looper is quit before the delivery time of the message

    occurs then the message will be dropped.

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

}

由上面的代码可以看出，Handler的sendMessage方法最后调用了sendMessageAtTime这个方法，其实，无论时sendMessage、sendEmptyMessage等方法最终都是调用sendMessageAtTime。可以看到sendMessageAtTime这个方法最后返回的是_enqueueMessage(queue, msg, uptimeMillis);_下面看下这个方法，代码如下

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

msg.target = this;

if (mAsynchronous) {

msg.setAsynchronous(true);

}

return queue.enqueueMessage(msg, uptimeMillis);

}

这里有一句代码非常重要，

msg.target = this;

这句代码就是将当前的Handler赋值给了Message中的target变量。这样，就将每个调用sendMessage方法的Handler与Message进行了绑定。

enqueueMessage方法最后返回的是**queue.enqueueMessage(msg, uptimeMillis);**也就是调用了MessageQueue中的enqueueMessage方法，下面看下MessageQueue中的enqueueMessage方法，代码如下

boolean enqueueMessage(Message msg, long when) {

if (msg.target == null) {

throw new IllegalArgumentException(“Message must have a target.”);

}

if (msg.isInUse()) {

throw new IllegalStateException(msg + " This message is already in use.");

}

synchronized (this) {

if (mQuitting) {

IllegalStateException e = new IllegalStateException(

msg.target + " sending message to a Handler on a dead thread");

Log.w(TAG, e.getMessage(), e);

msg.recycle();

return false;

}

msg.markInUse();

msg.when = when;

Message p = mMessages;

boolean needWake;

if (p == null || when == 0 || when < p.when) {

// New head, wake up the event queue if blocked.

msg.next = p;

mMessages = msg;

needWake = mBlocked;

} else {

// Inserted within the middle of the queue. Usually we don’t have to wake

// up the event queue unless there is a barrier at the head of the queue

// and the message is the earliest asynchronous message in the queue.

needWake = mBlocked && p.target == null && msg.isAsynchronous();

Message prev;

for (;😉 {

prev = p;

p = p.next;

if (p == null || when < p.when) {

break;

}

if (needWake && p.isAsynchronous()) {

needWake = false;

}

msg.next = p; // invariant: p == prev.next

prev.next = msg;

}

// We can assume mPtr != 0 because mQuitting is false.

if (needWake) {

nativeWake(mPtr);

}

return true;

}

上面的代码就是将消息放进消息队列中，如果消息已成功放入消息队列，则返回true。失败时返回false，而失败的原因通常是因为处理消息队列正在退出。代码分析到这里可以得出以下两点结论了

Handler在sendMessage时会将自己设置给Message的target变量即将自己与发送的消息绑定。
Handler的sendMessage是将Message放入MessageQueue中。

到了这里已经知道Handler的sendMessage是将消息放进MessageQueue中，那么又是怎样从MessageQueue中拿到消息的呢？想要知道答案请继续阅读。

怎样从MessageQueue中获取Message

在文章的前面，贴出了ActivityThread类中的main方法的代码，不知道细心的你有没有注意到，在main方法的结尾处调用了一句代码

Looper.loop();

好了，现在可以看看_Looper.loop();_这句代码到底做了什么了loop方法中的代码如下

/**

Run the message queue in this thread. Be sure to call
{@link #quit()} to end the loop.

public static void loop() {

final Looper me = myLooper();//通过myLooper方法拿到与主线程绑定的Looper

if (me == null) {

throw new RuntimeException(“No Looper; Looper.prepare() wasn’t called on this thread.”);

}

final MessageQueue queue = me.mQueue;//从Looper中得到MessageQueue

// 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();

//开始死循环

for (;😉 {

//从消息队列中不断取出消息

Message msg = queue.next(); // might block

if (msg == null) {

// No message indicates that the message queue is quitting.

return;

}

// This must be in a local variable, in case a UI event sets the logger

final Printer logging = me.mLogging;

if (logging != null) {

logging.println(">>>>> Dispatching to " + msg.target + " " +

msg.callback + ": " + msg.what);

}

final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

final long traceTag = me.mTraceTag;

if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {

Trace.traceBegin(traceTag, msg.target.getTraceName(msg));

}

final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();

final long end;

try {

//这句代码是重点

msg.target.dispatchMessage(msg);

end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();

} finally {

if (traceTag != 0) {

Trace.traceEnd(traceTag);

}

if (slowDispatchThresholdMs > 0) {

final long time = end - start;

if (time > slowDispatchThresholdMs) {

Slog.w(TAG, "Dispatch took " + time + "ms on "

Thread.currentThread().getName() + “, h=” +

msg.target + " cb=" + msg.callback + " msg=" + msg.what);

}

if (logging != null) {

logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);

}

// 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.recycleUnchecked();

}

上面的代码，我已经进行了部分注释，这里有一句代码非常重要

msg.target.dispatchMessage(msg);

执行到这句代码，说明已经从消息队列中拿到了消息，还记得msg.target吗？就是Message中的target变量呀！也就是发送消息的那个Handler，所以这句代码的本质就是调用了Handler中的dispatchMessage(msg)方法，代码分析到这里是不是有点小激动了呢！稳住！下面看下dispatchMessage(msg)这个方法，代码如下

/**

Handle system messages here.

public void dispatchMessage(Message msg) {

if (msg.callback != null) {

handleCallback(msg);

} else {

if (mCallback != null) {

if (mCallback.handleMessage(msg)) {

return;

}

handleMessage(msg);

}

现在来一句句的来分析上面的代码，先看下这句

if (msg.callback != null) {

handleCallback(msg);

}

msg.callback就是Runnable对象，当msg.callback不为null时会调用 handleCallback(msg)方法，先来看下 handleCallback(msg)方法，代码如下

private static void handleCallback(Message message) {

message.callback.run();

}

上面的代码就是调用了Runnable的run方法。那什么情况下**if (msg.callback != null)**这个条件成立呢！还记得使用Handler的另一种方法吗？就是调用Handler的post方法呀！这里说明一下，使用Handler其实是有两种方法的

使用Handler的sendMessage方法，最后在handleMessage(Message msg)方法中来处理消息。
使用Handler的post方法，最后在Runnable的run方法中来处理，代码如下

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

private Button mTimeCycle,mStopCycle;

private Runnable mRunnable;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

initView();

}

private void initView() {

mTimeCycle = findViewById(R.id.btn_time_cycle);

mTimeCycle.setOnClickListener(this);

mStopCycle = findViewById(R.id.btn_stop_cycle);

mStopCycle.setOnClickListener(this);

mRunnable = new Runnable() {

@Override

public void run() {

Toast.makeText(MainActivity.this, “正在循环！！！”, Toast.LENGTH_SHORT).show();

mHandler.postDelayed(mRunnable, 1000);

}

};

}

@Override

public void onClick(View v) {

switch (v.getId()) {

case R.id.btn_time_cycle:

mHandler.post(mRunnable);

break;

case R.id.btn_stop_cycle:

mHandler.removeCallbacks(mRunnable);

break;

}

第一种方法，我们已经分析了，下面来分析一下第二种使用方式的原理，先看下Handler的post的方法做了什么，代码如下

/**

Causes the Runnable r to be added to the message queue.
The runnable will be run on the thread to which this handler is
attached.
@param r The Runnable that will be executed.
@return Returns true if the Runnable was successfully placed in to the

    message queue.  Returns false on failure, usually because the

    looper processing the message queue is exiting.

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

最后

题外话，我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在IT学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多程序员朋友无法获得正确的资料得到学习提升，故此将并将重要的Android进阶资料包括自定义view、性能优化、MVC与MVP与MVVM三大框架的区别、NDK技术、阿里面试题精编汇总、常见源码分析等学习资料。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

Android开发8年，阿里、百度一面惨被吊打！我是否应该转行了？