子线程一定不能更新UI么？为什么？

客官°小女子只卖身不卖艺 2023-10-06 10:53 140阅读 0赞

#### 前言 ####

平时我们在开发过程中知道主线程不能进行耗时操作，子线程不能更新UI，于是有了线程间通讯，有了Handler机制，那么子线程真的不能更新UI么？很多小伙伴在面试的时候也会经常被问到这个问题，网上已经有了不少详解这一问题的博客，不过这里我还是带着复习一遍的态度，把这个流程再摸一遍。

#### 正文 ####

子线程一定不能更新UI么？

先说答案：是不一定，在Activity的onResume声明周期之前就可以。

下面我们看一下原理：

我们都知道在Android中有一个ActivityThread类，这个类非常重要，包括Activity的创建都和这个类有关，而且ActivityThread的main方法中还有Looper.preMainLooper，说明主线程的Looper也是在这里创建的，还有Looper.looper也是在这个地方调用的，还创建了主线程的Handler H：

final H mH = new H();

class H extends Handler {
        ...
    }

在这里我们看ActivityThread这个类当中的一个方法handleResumeActivity：

@Override
        public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
                String reason) {
            ...
            final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
            
    
                r.activity.mVisibleFromServer = true;
                mNumVisibleActivities++;
                if (r.activity.mVisibleFromClient) {
                    r.activity.makeVisible();
                }
            ...
        }

只看这里主要的几行代码，发现这里调用了performResumeActivity方法：

@VisibleForTesting
        public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,
                String reason) {
            ...
                r.activity.performResume(r.startsNotResumed, reason);
    
                r.state = null;
                r.persistentState = null;
                r.setState(ON_RESUME);
            ...
            return r;
        }

里面又调用了Activity中的performResume方法：

final void performResume(boolean followedByPause, String reason) {
            ...
    
            // mResumed is set by the instrumentation
            mInstrumentation.callActivityOnResume(this);
            writeEventLog(LOG_AM_ON_RESUME_CALLED, reason);
            ...
        }

这里又调用了Instrumentation的callActivityOnResume方法：

public void callActivityOnResume(Activity activity) {
            activity.mResumed = true;
            activity.onResume();
            
            if (mActivityMonitors != null) {
                synchronized (mSync) {
                    final int N = mActivityMonitors.size();
                    for (int i=0; i<N; i++) {
                        final ActivityMonitor am = mActivityMonitors.get(i);
                        am.match(activity, activity, activity.getIntent());
                    }
                }
            }
        }

到这里我们终于明白了，这里调用了activity.onResume方法，说明是在这里执行了Activity的onResume回调函数。

再反过头来看一下，我们最开始ActivityThread类handleResumeActivity中的另一行代码：

r.activity.makeVisible();

是调用了Activity中的makeVisible方法：

void makeVisible() {
            if (!mWindowAdded) {
                ViewManager wm = getWindowManager();
                wm.addView(mDecor, getWindow().getAttributes());
                mWindowAdded = true;
            }
            mDecor.setVisibility(View.VISIBLE);
    }

这里通过getWindowManager方法获取到了一个ViewManager，在这里我们要说明的一点是，getWindowManager方法返回的是一个WindowManager类的对象，而WindowManager是一个接口继承于ViewManager。而这里得到的ViewManager对象实际上是WindowManager的实现类WindowManagerImpl。然后调用WindowManagerImpl中的addView方法：

@Override
        public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
            applyDefaultToken(params);
            mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
        }

这里又调用了WindowManagerGlobal当中的addView方法：

public void addView(View view, ViewGroup.LayoutParams params,
                Display display, Window parentWindow) {
            ...
    
            ViewRootImpl root;
            View panelParentView = null;
    
            synchronized (mLock) {
                ...
    
                root = new ViewRootImpl(view.getContext(), display);
    
                view.setLayoutParams(wparams);
    
                mViews.add(view);
                mRoots.add(root);
                mParams.add(wparams);
    
                // do this last because it fires off messages to start doing things
                try {
                    root.setView(view, wparams, panelParentView);
                } catch (RuntimeException e) {
                    // BadTokenException or InvalidDisplayException, clean up.
                    if (index >= 0) {
                        removeViewLocked(index, true);
                    }
                    throw e;
                }
            }
        }

在这里我们看到创建了一个ViewRootImpl的实例，并调用了ViewRootImpl的setView方法：

/**
         * We have one child
         */
        public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
                    ...
                
                    requestLayout();
                    
                    ...
        }

发现这里调用了ViewRootImpl中的requestLayout方法：

@Override
        public void requestLayout() {
            if (!mHandlingLayoutInLayoutRequest) {
                checkThread();
                mLayoutRequested = true;
                scheduleTraversals();
            }
        }

在requestLayout方法中，我们看到有调用一个checkThread方法和一个scheduleTraversals方法：

我们先看checkThread方法：

void checkThread() {
            if (mThread != Thread.currentThread()) {
                throw new CalledFromWrongThreadException(
                        "Only the original thread that created a view hierarchy can touch its views.");
            }
        }

我们发现这里是做了一个线程的判断，拿主线程和当前线程做了一个判断，也就是说如果当前线程不是主线程那么就会抛出一个CalledFromWrongThreadException异常。

由此看来是在Activity的onResume回调函数之后做的checkThread线程判断。所以说我们只要在Activity的onResume回调函数之前在子线程更新UI就不会抛异常。（也就是在onResume回调函数的super.onResume函数之前调用，就不会抛异常）。

好了，说到这里，我们已经解答了本篇文章的问题，但是刚才那个scheduleTraversals方法我们也来分析一下：

void scheduleTraversals() {
            if (!mTraversalScheduled) {
                mTraversalScheduled = true;
                mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
                mChoreographer.postCallback(
                        Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
                if (!mUnbufferedInputDispatch) {
                    scheduleConsumeBatchedInput();
                }
                notifyRendererOfFramePending();
                pokeDrawLockIfNeeded();
            }
        }

我们看这里，调用了

mChoreographer.postCallback(
                        Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

我们看一下这里的mTraversalRunnable：

final class TraversalRunnable implements Runnable {
            @Override
            public void run() {
                doTraversal();
            }
        }
        final TraversalRunnable mTraversalRunnable = new TraversalRunnable();

里面的run方法调用了doTraversal方法：

void doTraversal() {
            if (mTraversalScheduled) {
                mTraversalScheduled = false;
                mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
    
                if (mProfile) {
                    Debug.startMethodTracing("ViewAncestor");
                }
    
                performTraversals();
    
                if (mProfile) {
                    Debug.stopMethodTracing();
                    mProfile = false;
                }
            }
        }

这里又调用了performTraversals方法：

在performTraversals方法里面分别调用了：performMeasure()、performLayout()、performDraw()方法。

而这三个方法又分别调用了measure、layout、draw。

又由于measure方法是final类型的，不可被子类继承所以对外提供了onMeasure方法，所以我们在自定义View的使用，重写的是onMeasure、onLayout、onDraw方法。

#### 总结 ####

Android可以在子线程更新UI，但是前提是要在Activity的onResume回调方法前调用子线程更新UI的操作。不过我们一般不这样搞，还是遵循主线程更新UI，子线程进行耗时操作的逻辑比较合理一些。