A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

1黑马币
本帖最后由 杨顺发老师 于 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.             }

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

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

  70.                 Looper.myQueue().addIdleHandler(new Idler());
  71.             }
  72.             r.onlyLocalRequest = false;

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

  74.         } else {
  75.             // 省略异常发生时对Activity的处理逻辑
  76.         }
  77.     }

  78.     // 省去巨量代码……………………
  79. }
  80. <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




1 个回复

倒序浏览
报的Android就业班,感觉Android也挺难的!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马