为什么我们可以在非UI线程中更新UI

尊重原创转载请注明：From AigeStudio（http://blog.csdn.net/aigestudio）Power by Aige 侵权必究！

炮兵镇楼

看到这样的标题……估计N多人会说我是逗比…………因为很多盆友在学习Android（特别是从4.0之后开始入门的）的时候都会常看见或听到别人说我们更新UI呢要在UI线程（或者说主线程）中去更新UI，不要在子线程中更新UI，而Android官方呢也建议我们不要在非UI线程直接更新UI，为什么呢？借助Android官方的一句话来说就是：

“The Android UI toolkit is not thread-safe and the view must always be manipulated on the UI thread.”

因此，很多童鞋会有这么一个惯性思维：在非UI线程中不能更新UI！既然Android不建议我们这么做，那其必定会对我们在code时做一些限制，比如当我们尝试运行如下代码时：

[java] view plaincopyprint?

1. /** 
2.  * 主界面 
3.  *  
4.  * @author Aige {@link http://blog.csdn.net/aigestudio} 
5.  * @since 2014/11/17 
6.  */  
7. public class MainActivity extends Activity {  
8.     private TextView tvText;  
9.   
10.     @Override  
11.     public void onCreate(Bundle savedInstanceState) {  
12.         super.onCreate(savedInstanceState);  
13.         setContentView(R.layout.activity_main);  
14.   
15.         tvText = (TextView) findViewById(R.id.main_tv);  
16.         new Thread(new Runnable() {  
17.             @Override  
18.             public void run() {  
19.                 try {  
20.                     Thread.sleep(200);  
21.                 } catch (InterruptedException e) {  
22.                     e.printStackTrace();  
23.                 }  
24.                 tvText.setText("OtherThread");  
25.             }  
26.         }).start();  
27.     }  
28. }  

为了把情况说明，这里我也将xml布局文件代码贴出来：

[html] view plaincopyprint?

1. <!-- http://blog.csdn.net/aigestudio -->  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="match_parent"  
4.     android:background="#ffffff"  
5.     android:layout_height="match_parent" >  
6.   
7.     <TextView  
8.         android:id="@+id/main_tv"  
9.         android:layout_width="wrap_content"  
10.         android:layout_height="wrap_content" />  
11.   
12. </LinearLayout>  

当我们运行上述代码后，你便会在Logcat中得到如下error提示：

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

这句话非常简单，而且……我相信每个做Android开发到一定时间的盆友都碰到过，Android通过检查我们当前的线程是否为UI线程从而抛出一个自定义的AndroidRuntimeException来提醒我们“Only the original thread that created a view hierarchy can touch its views”并强制终止程序运行，具体的实现在ViewRootImpl类的checkThread方法中：

[java] view plaincopyprint?

1. @SuppressWarnings({"EmptyCatchBlock", "PointlessBooleanExpression"})  
2. public final class ViewRootImpl implements ViewParent,  
3.         View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {  
4.     // 省去海量代码…………………………  
5.   
6.     void checkThread() {  
7.         if (mThread != Thread.currentThread()) {  
8.             throw new CalledFromWrongThreadException(  
9.                     "Only the original thread that created a view hierarchy can touch its views.");  
10.         }  
11.     }  
12.   
13.     // 省去巨量代码……………………  
14. }  

这就是Android在4.0后对我们做出的一个限制。写这篇Blog的具体原因来自凯子哥的一篇博文：来来来，同学，咱们讨论一下“只能在UI主线程更新View”这件小事，鉴于凯子哥如此好学，我想想呢也许很多盆友也有类似疑问：究竟TM到底能不能在非UI线程中更新UI呢？同时也为了引出我对在非UI线程更新UI方法的一些总结，我决定在3/4之前先撸一篇Blog扫清障碍先。首先，我先回答几个问题包括凯子哥的：

1. 究竟TM到底能不能在非UI线程中更新UI呢？答案：能、当然可以
2. View的运行和Activity的生命周期有什么必然联系吗？答案：没有、或者隐晦地说没有必然联系
3. 除了Handler外是否还有更简便的方式在非UI线程更新UI呢？答案：有、而且还不少

OK，这里我们再来看一下上面的一段代码，在线程中我调用了Thread.sleep(200);来让我们的匿名线程暂停了200ms，如果……假如……我们去掉它的话……………………会发生什么？来试试：

[java] view plaincopyprint?

1. /** 
2.  * 主界面 
3.  *  
4.  * @author Aige {@link http://blog.csdn.net/aigestudio} 
5.  * @since 2014/11/17 
6.  */  
7. public class MainActivity extends Activity {  
8.     private TextView tvText;  
9.   
10.     @Override  
11.     public void onCreate(Bundle savedInstanceState) {  
12.         super.onCreate(savedInstanceState);  
13.         setContentView(R.layout.activity_main);  
14.   
15.         tvText = (TextView) findViewById(R.id.main_tv);  
16.         new Thread(new Runnable() {  
17.             @Override  
18.             public void run() {  
19.                 tvText.setText("OtherThread");  
20.             }  
21.         }).start();  
22.     }  
23. }  

这时你会发现我们的代码TM地正确执行了！而且我们的TextView正确显示出了“OtherThread”文本！看到屏幕上的这11个英文字母我相信大家又把刚放出来又吸进去的屁再一次地放了出来…………这就是凯子哥Blog中提到的问题，我们成功地在非UI线程中更新了UI。其实这里最最根本的原因是我们并没有checkThread我们的当前线程，而我在文章最开始的代码中通过Thread.sleep(200)暂停了一小段时间，这里为什么回暂停线程一段时间？在这段时间的背后Android背地里背着我们都干了什么？数百头母驴为何半夜惨叫？小卖部安全套为何屡遭黑手？女生宿舍内裤为何频频失窃？连环强奸母猪案，究竟是何人所为？老尼姑的门夜夜被敲，究竟是人是鬼？数百只小母狗意外身亡的背后又隐藏着什么？这一切的背后， 是人性的扭曲还是道德的沦丧？是性的爆发还是饥渴的无奈？抱歉……磕个药，上面我们讲到，我们能正确以上述代码的方式在非UI线程中更新UI而不报错，那么原因也许只有一个，那就是没有执行checkThread方法去检查我们的当前线程……但是，细看调用checkThread方法的调用方法们你就会发现，TM全是跟View创建生成相关：

也就是说一旦我们尝试去对我们的控件进行生成，这些方法其中一个必然会被调用，这时候很多朋友就会蛋疼了…………但是，请不要被checkThread方法的思维所束缚，这时候你该扩大你的思维范畴，既然checkThread方法属于ViewRootImpl的成员方法，那么会不会是此时我们的ViewRootImpl根本就没被创建呢？怀着这个出发点，我们再度审视ActivtyThread调度Activity生命周期的各个环节，首先看看performLaunchActivity方法中的处理：

[java] view plaincopyprint?

1. public final class ActivityThread {  
2.     // 省去海量代码…………………………  
3.   
4.     private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {  
5.         ActivityInfo aInfo = r.activityInfo;  
6.           
7.         // 省去对packageInfo的逻辑处理  
8.   
9.         // 省去对ComponentName的逻辑处理  
10.   
11.         Activity activity = null;  
12.         try {  
13.             java.lang.ClassLoader cl = r.packageInfo.getClassLoader();  
14.   
15.             // 通过Instrumentation对象生成Activity类的实例  
16.             activity = mInstrumentation.newActivity(  
17.                     cl, component.getClassName(), r.intent);  
18.               
19.             // 省去三行代码…………  
20.         } catch (Exception e) {  
21.             // 省去对异常的捕获处理  
22.         }  
23.   
24.         try {  
25.             Application app = r.packageInfo.makeApplication(false, mInstrumentation);  
26.   
27.             // 省去多行无关代码  
28.   
29.             if (activity != null) {  
30.                 Context appContext = createBaseContextForActivity(r, activity);  
31.                 CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());  
32.                 Configuration config = new Configuration(mCompatConfiguration);  
33.   
34.                 // 省去多行无关代码  
35.   
36.                 if (customIntent != null) {  
37.                     activity.mIntent = customIntent;  
38.                 }  
39.                 r.lastNonConfigurationInstances = null;  
40.                 activity.mStartedActivity = false;  
41.                 int theme = r.activityInfo.getThemeResource();  
42.                 if (theme != 0) {  
43.                     activity.setTheme(theme);  
44.                 }  
45.   
46.                 /* 
47.                  * 调用callActivityOnCreate方法处理Create逻辑 
48.                  */  
49.                 activity.mCalled = false;  
50.                 mInstrumentation.callActivityOnCreate(activity, r.state);  
51.                 if (!activity.mCalled) {  
52.                     // 省去多行无关代码  
53.                 }  
54.                 r.activity = activity;  
55.                 r.stopped = true;  
56.   
57.                 /* 
58.                  * 调用performStart方法处理Start逻辑 
59.                  */  
60.                 if (!r.activity.mFinished) {  
61.                     activity.performStart();  
62.                     r.stopped = false;  
63.                 }  
64.                 // 省去多行无关代码  
65.             }  
66.             // 省去两行无关代码  
67.   
68.         } catch (SuperNotCalledException e) {  
69.             // 省去对异常的捕获处理  
70.   
71.         } catch (Exception e) {  
72.             // 省去对异常的捕获处理  
73.         }  
74.   
75.         return activity;  
76.     }  
77.   
78.     // 省去巨量代码……………………  
79. }  

performLaunchActivity方法中目测木有我我们想要的信息，其创建了Activity并调度了Create和Start的逻辑处理，那我们看看callActivityOnCreate方法呢：

[java] view plaincopyprint?

1. public class Instrumentation {  
2.     // 省去海量代码…………………………  
3.   
4.     public void callActivityOnCreate(Activity activity, Bundle icicle) {  
5.         // 省去某些逻辑……  
6.           
7.         activity.performCreate(icicle);  
8.           
9.         // 省去某些逻辑……  
10.     }  
11.   
12.     // 省去巨量代码……………………  
13. }  

callActivityOnCreate中除了对MQ的一些调度外最重要的还是通过Activity的实例调用了performCreate方法：

[java] view plaincopyprint?

1. public class Activity extends ContextThemeWrapper  
2.         implements LayoutInflater.Factory2,  
3.         Window.Callback, KeyEvent.Callback,  
4.         OnCreateContextMenuListener, ComponentCallbacks2 {  
5.     // 省去海量代码…………………………  
6.   
7.     final void performCreate(Bundle icicle) {  
8.         onCreate(icicle);  
9.         mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(  
10.                 com.android.internal.R.styleable.Window_windowNoDisplay, false);  
11.         mFragments.dispatchActivityCreated();  
12.     }  
13.   
14.     // 省去巨量代码……………………  
15. }  

performCreate方法逻辑就更干脆了，最主要的还是调用了我们Activity的onCreate方法，我们没在这里找到我们想要的东西，那再来看performStart：

[java] view plaincopyprint?

1. public class Activity extends ContextThemeWrapper  
2.         implements LayoutInflater.Factory2,  
3.         Window.Callback, KeyEvent.Callback,  
4.         OnCreateContextMenuListener, ComponentCallbacks2 {  
5.     // 省去海量代码…………………………  
6.   
7.     final void performStart() {  
8.         mFragments.noteStateNotSaved();  
9.         mCalled = false;  
10.         mFragments.execPendingActions();  
11.         mInstrumentation.callActivityOnStart(this);  
12.         if (!mCalled) {  
13.             throw new SuperNotCalledException(  
14.                 "Activity " + mComponent.toShortString() +  
15.                 " did not call through to super.onStart()");  
16.         }  
17.         mFragments.dispatchStart();  
18.         if (mAllLoaderManagers != null) {  
19.             final int N = mAllLoaderManagers.size();  
20.             LoaderManagerImpl loaders[] = new LoaderManagerImpl[N];  
21.             for (int i=N-1; i>=0; i--) {  
22.                 loaders[i] = mAllLoaderManagers.valueAt(i);  
23.             }  
24.             for (int i=0; i<N; i++) {  
25.                 LoaderManagerImpl lm = loaders[i];  
26.                 lm.finishRetain();  
27.                 lm.doReportStart();  
28.             }  
29.         }  
30.     }  
31.   
32.     // 省去巨量代码……………………  
33. }  

performStart相对于performCreate有更多的逻辑处理，但依然木有我们想要的结果，其最终还是同过Instrumentation对象调用callActivityOnStart：

[java] view plaincopyprint?

1. public class Instrumentation {  
2.     // 省去海量代码…………………………  
3.   
4.     public void callActivityOnStart(Activity activity) {  
5.         activity.onStart();  
6.     }  
7.   
8.     // 省去巨量代码……………………  
9. }  

callActivityOnStart仅仅是调用了Activity的onStart方法，同样……onStart方法中也没有我们想要的结果~~~~我们抱着即将从埃菲尔铁塔顶端做自由落体的心态继续看onResume方法的调度，其在ActivityThread中通过handleResumeActivity调度：

[java] view plaincopyprint?

1. public final class ActivityThread {  
2.     // 省去海量代码…………………………  
3.   
4.     final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward,  
5.             boolean reallyResume) {  
6.         unscheduleGcIdler();  
7.   
8.         ActivityClientRecord r = performResumeActivity(token, clearHide);  
9.   
10.         if (r != null) {  
11.             final Activity a = r.activity;  
12.   
13.             // 省去无关代码…………  
14.   
15.             final int forwardBit = isForward ?  
16.                     WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;  
17.   
18.             boolean willBeVisible = !a.mStartedActivity;  
19.             if (!willBeVisible) {  
20.                 try {  
21.                     willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(  
22.                             a.getActivityToken());  
23.                 } catch (RemoteException e) {  
24.                 }  
25.             }  
26.             if (r.window == null && !a.mFinished && willBeVisible) {  
27.                 r.window = r.activity.getWindow();  
28.                 View decor = r.window.getDecorView();  
29.                 decor.setVisibility(View.INVISIBLE);  
30.                 ViewManager wm = a.getWindowManager();  
31.                 WindowManager.LayoutParams l = r.window.getAttributes();  
32.                 a.mDecor = decor;  
33.                 l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;  
34.                 l.softInputMode |= forwardBit;  
35.                 if (a.mVisibleFromClient) {  
36.                     a.mWindowAdded = true;  
37.                     wm.addView(decor, l);  
38.                 }  
39.   
40.             } else if (!willBeVisible) {  
41.                 // 省去无关代码…………  
42.   
43.                 r.hideForNow = true;  
44.             }  
45.   
46.             cleanUpPendingRemoveWindows(r);  
47.   
48.             if (!r.activity.mFinished && willBeVisible  
49.                     && r.activity.mDecor != null && !r.hideForNow) {  
50.                 if (r.newConfig != null) {  
51.                     // 省去无关代码…………  
52.   
53.                     performConfigurationChanged(r.activity, r.newConfig);  
54.                     freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(r.newConfig));  
55.                     r.newConfig = null;  
56.                 }  
57.   
58.                 // 省去无关代码…………  
59.   
60.                 WindowManager.LayoutParams l = r.window.getAttributes();  
61.                 if ((l.softInputMode  
62.                         & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)  
63.                         != forwardBit) {  
64.                     l.softInputMode = (l.softInputMode  
65.                             & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))  
66.                             | forwardBit;  
67.                     if (r.activity.mVisibleFromClient) {  
68.                         ViewManager wm = a.getWindowManager();  
69.                         View decor = r.window.getDecorView();  
70.                         wm.updateViewLayout(decor, l);  
71.                     }  
72.                 }  
73.                 r.activity.mVisibleFromServer = true;  
74.                 mNumVisibleActivities++;  
75.                 if (r.activity.mVisibleFromClient) {  
76.                     r.activity.makeVisible();  
77.                 }  
78.             }  
79.   
80.             if (!r.onlyLocalRequest) {  
81.                 r.nextIdle = mNewActivities;  
82.                 mNewActivities = r;  
83.   
84.                 // 省去无关代码…………  
85.   
86.                 Looper.myQueue().addIdleHandler(new Idler());  
87.             }  
88.             r.onlyLocalRequest = false;  
89.   
90.             // 省去与ActivityManager的通信处理  
91.   
92.         } else {  
93.             // 省略异常发生时对Activity的处理逻辑  
94.         }  
95.     }  
96.   
97.     // 省去巨量代码……………………  
98. }  

handleResumeActivity方法逻辑相对要复杂一些，除了一啪啦对当前显示Window的逻辑判断以及没创建的初始化等等工作外其在最终会调用Activity的makeVisible方法：

[java] view plaincopyprint?

1. public class Activity extends ContextThemeWrapper  
2.         implements LayoutInflater.Factory2,  
3.         Window.Callback, KeyEvent.Callback,  
4.         OnCreateContextMenuListener, ComponentCallbacks2 {  
5.     // 省去海量代码…………………………  
6.   
7.     void makeVisible() {  
8.         if (!mWindowAdded) {  
9.             ViewManager wm = getWindowManager();  
10.             wm.addView(mDecor, getWindow().getAttributes());  
11.             mWindowAdded = true;  
12.         }  
13.         mDecor.setVisibility(View.VISIBLE);  
14.     }  
15.   
16.     // 省去巨量代码……………………  
17. }  

在makeVisible方法中逻辑相当简单，获取一个窗口管理器对象并将我们曾在自定义控件其实很简单7/12中提到过的根视图DecorView添加到其中，addView的具体实现在WindowManagerGlobal中：

[java] view plaincopyprint?

1. public final class WindowManagerGlobal {  
2.     public void addView(View view, ViewGroup.LayoutParams params,  
3.             Display display, Window parentWindow) {  
4.         // 省去很多代码  
5.   
6.         ViewRootImpl root;  
7.   
8.         // 省去一行代码  
9.   
10.         synchronized (mLock) {  
11.             // 省去无关代码  
12.   
13.             root = new ViewRootImpl(view.getContext(), display);  
14.   
15.             // 省去一行代码  
16.   
17.             // 省去一行代码  
18.   
19.             mRoots.add(root);  
20.   
21.             // 省去一行代码  
22.         }  
23.   
24.         // 省去部分代码  
25.     }  
26. }  

在addView生成了一个ViewRootImpl对象并将其保存在了mRoots数组中，每当我们addView一次，就会生成一个ViewRootImpl对象，其实看到这里我们还可以扩展一下问题一个APP是否可以拥有多个根视图呢？答案是肯定的，因为只要我调用了addView方法，我们传入的View参数就可以被认为是一个根视图，但是！在framework的默认实现中有且仅有一个根视图，那就是我们上面makeVisible方法中addView进去的DecorView，所以为什么我们可以说一个APP虽然可以有多个Activity，但是每个Activity只会有一个Window一个DecorView一个ViewRootImpl，看到这里很多童鞋依然会问，也就是说在onResume方法被执行后我们的ViewRootImpl才会被生成对吧，但是为什么下面的代码依然可以正确运行呢：

[java] view plaincopyprint?

1. /** 
2.  * 主界面 
3.  *  
4.  * @author Aige {@link http://blog.csdn.net/aigestudio} 
5.  * @since 2014/11/17 
6.  */  
7. public class MainActivity extends Activity {  
8.     private TextView tvText;  
9.   
10.     @Override  
11.     public void onCreate(Bundle savedInstanceState) {  
12.         super.onCreate(savedInstanceState);  
13.         setContentView(R.layout.activity_main);  
14.   
15.         tvText = (TextView) findViewById(R.id.main_tv);  
16.     }  
17.       
18.     @Override  
19.     protected void onResume() {  
20.         super.onResume();  
21.         new Thread(new Runnable() {  
22.             @Override  
23.             public void run() {  
24.                 tvText.setText("OtherThread");  
25.             }  
26.         }).start();  
27.     }  
28. }  

没错，可以执行！首先我们这里的是个线程，其次这里要涉及framework对UI事件处理的方式，我们在Android翻页效果原理实现之引入折线中曾说过Android对UI事件的处理需要依赖于Message Queue，当一个Msg被压入MQ到处理这个过程并非立即的，它需要一段事件，我们在线程中通过Thread.sleep(200)在等，在等什么呢？在等ViewRootImpl的实例对象被创建，有关于GUI中Message Queue的处理如有机会我会浓缩在《深入理解 Android GUI 框架》系列中，这里就暂且先不说了，那么又有同学会问了！纳尼，既然ViewRootImpl还未被创建那么为什么会能绘制出文本？！！！如果你有这个疑问，我只能说你观察细致问得好，但是，这个问题我不打算解答，留给各位，上面我其实就在教大家如何去寻找原因了，渔已授之于你所以就不再多说了~~~~既然我们找到了原因所在，那么我们该如何摆脱“The Android UI toolkit is not thread-safe and the view must always be manipulated on the UI thread.”这个噩梦呢？