黑马程序员技术交流社区

标题: [Android] [深圳特色][问答网]为什么我们可以在非UI线程中修... [打印本页]
作者: 杨顺发老师    时间: 2015-12-27 17:22
标题: [Android] [深圳特色][问答网]为什么我们可以在非UI线程中修...
本帖最后由 杨顺发老师 于 2015-12-27 17:09 编辑

看到标题，大伙是否毫无疑问以为发哥是不是嗑药了？这不，有同学问了，那，咳咳，且听我慢慢道来。
同学提问：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.             }

  67.             if (!r.onlyLocalRequest) {
  68.                 r.nextIdle = mNewActivities;
  69.                 mNewActivities = r;

  71.                 // 省去无关代码…………

  73.                 Looper.myQueue().addIdleHandler(new Idler());
  74.             }
  75.             r.onlyLocalRequest = false;

  77.             // 省去与ActivityManager的通信处理

  79.         } else {
  80.             // 省略异常发生时对Activity的处理逻辑
  81.         }
  82.     }

  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 侵权必究！

[attach]96217[/attach]
[深圳特色] 揭秘内部问答网中经典问题，每周更新！
深圳校区除了全国独有问答网，就业老师面试服务，还有更多神秘惊喜等着你，咨询热线：0755-66689855




作者: s1714534118    时间: 2015-12-30 14:01
报的Android就业班，感觉Android也挺难的！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2