看到标题，大伙是否毫无疑问以为发哥是不是嗑药了？这不，有同学问了，那，咳咳，且听我慢慢道来。
同学提问：Android中非UI线程可以修改UI么？
发哥回答：

首先，你说的2.3中可以应该是说主线程中请求网络，而不是修改ui。

其次，非UI线程中可以修改UI。

我们在学习过程中，说得非常多的就是：使用Handler发送消息到UI线程去刷新view。

更新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时做一些限制，比如当我们尝试运行如下代码时：

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

复制代码

当我们运行上述代码后，你便会在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方法中：

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

复制代码

这就是Android在4.0后对我们做出的一个限制。

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

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

复制代码

这时你会发现我们的代码正确执行了！而且我们的TextView正确显示出了“OtherThread”文本——我们成功地在非UI线程中更新了UI。其实这里最最根本的原因是我们并没有checkThread我们的当前线程，而我在文章最开始的代码中通过Thread.sleep(200)暂停了一小段时间，这里为什么回暂停线程一段时间？在这段时间的背后Android背地里背着我们都干了什么？上面我们讲到，我们能正确以上述代码的方式在非UI线程中更新UI而不报错，那么原因也许只有一个，那就是没有执行checkThread方法去检查我们的当前线程……但是，细看调用checkThread方法的调用方法们你就会发现，全是跟View创建生成相关：

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

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

复制代码

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

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

复制代码

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

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

复制代码

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

1. public class Instrumentation {
   
2. // 省去海量代码…………………………
   
3.     public void callActivityOnStart(Activity activity) {
   
4.         activity.onStart();
   
5.     }
   
6. // 省去巨量代码……………………
   
7. }
   
8. <div align="left"></div>

复制代码

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

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

复制代码

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

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

复制代码

在makeVisible方法中逻辑相当简单，获取一个窗口管理器对象并将根视图DecorView添加到其中，addView的具体实现在WindowManagerGlobal中：

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

复制代码

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

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

复制代码

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

本文修改自CSDN博客：From AigeStudio（http://blog.csdn.net/aigestudio）Power by Aige 侵权必究！

[深圳特色] 揭秘内部问答网中经典问题，每周更新！

深圳校区除了全国独有问答网，就业老师面试服务，还有更多神秘惊喜等着你，咨询热线：0755-66689855

报的Android就业班，感觉Android也挺难的！