歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

Android子線程真的不能更新UI麼

Android單線程模型是這樣描述的:

Android UI操作並不是線程安全的,並且這些操作必須在UI線程執行

  如果在其它線程訪問UI線程,Android提供了以下的方式:

Activity.runOnUiThread(Runnable)
View.post(Runnable)
View.postDelayed(Runnable, long)
Handler

  為什麼呢?在子線程中就不能操作UI麼?

  當一個程序第一次啟動的時候,Android會同時啟動一個對應的主線程,這個主線程就是UI線程,也就是ActivityThread。UI線程主要負責處理與UI相關的事件,如用戶的按鍵點擊、用戶觸摸屏幕以及屏幕繪圖等。系統不會為每個組件單獨創建一個線程,在同一個進程裡的UI組件都會在UI線程裡實例化,系統對每一個組件的調用都從UI線程分發出去。所以,響應系統回調的方法永遠都是在UI線程裡運行,如響應用戶動作的onKeyDown()的回調。

  那為什麼選擇一個主線程干這些活呢?換個說法,Android為什麼使用單線程模型,它有什麼好處?

  先讓我們看下單線程化的事件隊列模型是怎麼定義的:

采用一個專門的線程從隊列中抽取事件,並把他們轉發給應用程序定義的事件處理器

  這看起來就是Android的消息隊列、Looper和Handler嘛。類似知識請參考:深入理解Message, MessageQueue, Handler和Looper

  其實現代GUI框架就是使用了類似這樣的模型:模型創建一個專門的線程,事件派發線程來處理GUI事件。單線程化也不單單存在Android中,Qt、XWindows等都是單線程化。當然,也有人試圖用多線程的GUI,最終由於競爭條件和死鎖導致的穩定性問題等,又回到單線程化的事件隊列模型老路上來。單線程化的GUI框架通過限制來達到線程安全:所有GUI中的對象,包括可視組件和數據模型,都只能被事件線程訪問。

  這就解釋了Android為什麼使用單線程模型。

  那Android的UI操作並不是線程安全的又是怎麼回事?

  Android實現View更新有兩組方法,分別是invalidate和postInvalidate。前者在UI線程中使用,後者在非UI線程中使用。換句話說,Android的UI操作不是線程安全可以表述為invalidate在子線程中調用會導致線程不安全。作一個假設,現在我用invalidate在子線程中刷新界面,同時UI線程也在用invalidate刷新界面,這樣會不會導致界面的刷新不能同步?既然刷新不同步,那麼invalidate就不能在子線程中使用。這就是invalidate不能在子線程中使用的原因。

  postInvalidate可以在子線程中使用,它是怎麼做到的?

  看看源碼是怎麼實現的:

public void postInvalidate() {
    postInvalidateDelayed(0);
}

public void postInvalidateDelayed(long delayMilliseconds) {
    // We try only with the AttachInfo because there's no point in invalidating
    // if we are not attached to our window
    if (mAttachInfo != null) {
        Message msg = Message.obtain();
        msg.what = AttachInfo.INVALIDATE_MSG;
        msg.obj = this;
        mAttachInfo.mHandler.sendMessageDelayed(msg, delayMilliseconds);
    }
}

  說到底還是通過Handler的sendMessageDelayed啊,還是逃不過消息隊列,最終還是交給UI線程處理。所以View的更新只能由UI線程處理。

  如果我非要在子線程中更新UI,那會出現什麼情況呢?

android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

  拋了一個CalledFromWrongThreadException異常。

  相信很多人遇到這個異常後,就會通過前面的四種方式中的其中一種解決:

Activity.runOnUiThread(Runnable)
View.post(Runnable)
View.postDelayed(Runnable, long)
Handler

  說到底還沒觸發到根本,為什麼會出現這個異常呢?這個異常在哪裡拋出來的呢?

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

  該代碼出自 framework/base/core/java/android/view/ViewRootImpl.java

  再看下ViewRootImpl的構造函數,mThread就是在這初始化的:

public ViewRootImpl(Context context, Display display) {
    mContext = context;
    mWindowSession = WindowManagerGlobal.getWindowSession();
    mDisplay = display;
    mBasePackageName = context.getBasePackageName();

    mDisplayAdjustments = display.getDisplayAdjustments();

    mThread = Thread.currentThread();
    ......
}

  再研究一下這個CalledFromWrongThreadException異常的堆棧,會發現最後到了invalidateChild和invalidateChildInParent方法中:

@Override
public void invalidateChild(View child, Rect dirty) {
    invalidateChildInParent(null, dirty);
}

@Override
public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
    checkThread();
    ......
}

  最終通過checkThread形成了這個異常。說到底,非UI線程是可以刷新UI的呀,前提是它要擁有自己的ViewRoot。如果想直接創建ViewRoot實例,你會發現找不到這個類。那怎麼做呢?通過WindowManager。

class NonUiThread extends Thread{
      @Override
      public void run() {
        Looper.prepare();
        TextView tx = new TextView(MainActivity.this);
        tx.setText("non-UiThread update textview");
 
        WindowManager windowManager = MainActivity.this.getWindowManager();
        WindowManager.LayoutParams params = new WindowManager.LayoutParams(
            200, 200, 200, 200, WindowManager.LayoutParams.FIRST_SUB_WINDOW,
                WindowManager.LayoutParams.TYPE_TOAST,PixelFormat.OPAQUE);
        windowManager.addView(tx, params);
        Looper.loop();
    }
 }

  就是通過windowManager.addView創建了ViewRoot,WindowManagerImpl.java中的addView方法:

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

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

  mGlobal是一個WindowManagerGlobal實例,代碼在 frameworks/base/core/java/android/view/WindowManagerGlobal.java中,具體實現如下:

public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (display == null) {
            throw new IllegalArgumentException("display must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
        if (parentWindow != null) {
            parentWindow.adjustLayoutParamsForSubWindow(wparams);
        } else {
            // If there's no parent, then hardware acceleration for this view is
            // set from the application's hardware acceleration setting.
            final Context context = view.getContext();
            if (context != null
                    && (context.getApplicationInfo().flags
                            & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
                wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
            }
        }

        ViewRootImpl root;
        View panelParentView = null;

        synchronized (mLock) {
            // Start watching for system property changes.
            if (mSystemPropertyUpdater == null) {
                mSystemPropertyUpdater = new Runnable() {
                    @Override public void run() {
                        synchronized (mLock) {
                            for (int i = mRoots.size() - 1; i >= 0; --i) {
                                mRoots.get(i).loadSystemProperties();
                            }
                        }
                    }
                };
                SystemProperties.addChangeCallback(mSystemPropertyUpdater);
            }

            int index = findViewLocked(view, false);
            if (index >= 0) {
                if (mDyingViews.contains(view)) {
                    // Don't wait for MSG_DIE to make it's way through root's queue.
                    mRoots.get(index).doDie();
                } else {
                    throw new IllegalStateException("View " + view
                            + " has already been added to the window manager.");
                }
                // The previous removeView() had not completed executing. Now it has.
            }

            // If this is a panel window, then find the window it is being
            // attached to for future reference.
            if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
                    wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
                final int count = mViews.size();
                for (int i = 0; i < count; i++) {
                    if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
                        panelParentView = mViews.get(i);
                    }
                }
            }

            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.
            synchronized (mLock) {
                final int index = findViewLocked(view, false);
                if (index >= 0) {
                    removeViewLocked(index, true);
                }
            }
            throw e;
        }
    }

  所以,非UI線程能更新UI,只要它有自己的ViewRoot。

  延伸一下:Android Activity本身是在什麼時候創建ViewRoot的呢?

  既然是單線程模型,就要先找到這個UI線程實現類ActivityThread,看裡面哪裡addView了。沒錯,是在onResume裡面,對應ActivityThread就是handleResumeActivity這個方法:

final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume) {
        // If we are getting ready to gc after going to the background, well
        // we are back active so skip it.
        unscheduleGcIdler();
        mSomeActivitiesChanged = true;

        // TODO Push resumeArgs into the activity for consideration
        ActivityClientRecord r = performResumeActivity(token, clearHide);
        ......
        if (r.window == null && !a.mFinished && willBeVisible) {
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;
            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;
            if (a.mVisibleFromClient) {
                a.mWindowAdded = true;
                wm.addView(decor, l);
            }

        // If the window has already been added, but during resume
        // we started another activity, then don't yet make the
        // window visible.
        } else if (!willBeVisible) {
            if (localLOGV) Slog.v(
                TAG, "Launch " + r + " mStartedActivity set");
            r.hideForNow = true;
        }
    ......
}

  所以,如果在onCreate中通過子線程直接更新UI,並不會拋CalledFromWrongThreadException異常。但是一般情況下,我們不會在onCreate中做這樣的事情。

  這就是Android為我們設計的單線程模型,核心就是一句話:Android UI操作並不是線程安全的,並且這些操作必須在UI線程執行。但這一句話背後,卻隱藏著我們平時看不見的代碼實現,只有搞懂這些,我們才能知其然知其所以然。

更多Android相關信息見Android 專題頁面 http://www.linuxidc.com/topicnews.aspx?tid=11

Copyright © Linux教程網 All Rights Reserved