Only the original thread that created a view hierarchy can touch its views

原文：https://blog.csdn.net/breeze666/article/details/7570914

感谢博主分享，这里粘贴下来用作以后回看

很多网友在Android中使用多线程处理UI相关内容时可能会发现Logcat提示Only the original thread that created a view hierarchy can touch its views这样的错误，这主要是Android的相关View和控件不是线程安全的，我们必须做独立的处理这点比J2ME麻烦一些，这里Android给 我们提供了很多方法，有关线程的，我们需要了解下J2ME中一些传统的线程创建方法，比如Runnable或直接new Thread()，大家需要了解UI线程、worker线程以及一些概念。今天android开发网说一种简单的方法除了异步任务AsyncTask外使 用Handler可以很好的处理，和Win32的消息很像。

  首先我们需要明白，主线程或者这里说的原始线程original thread 一般情况下是UI线程，当然UI线程并不一定是主线程，我们不能长时间的阻塞该应用，在Android平台上可能会产生类似Force close或Wait这样的对话框这里我们成为ANR，这里除了使用ProgressDialog方式给用一个动态的进度代表当前处理并没有中断可能需要 一些时间，所以android123告诉大家相关的网络处理可以使用工作者线程，但是worker 线程不能处理显示元素即UI相关的View或 Widget包中的高层的控件，所以通过一个Handler对象可以很好的传递Runnable或Message ，下面我们用一个简单的例子来描述

  final Handler cwjHandler = new Handler();

   final Runnable mUpdateResults = new Runnable() {
        public void run() {
            updateUI();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

     NetworkOperation();//一个很费时间的I/O操作，比如网络或文件读写等等。

      }

    protected void NetworkOperation() {

        Thread t = new Thread() {
            public void run() {
                doSomething(); //处理得到结果了，这里一些内容保存在主类的成员变量中
                cwjHandler.post(mUpdateResults); //高速UI线程可以更新结果了
            }
        };
        t.start();
    }

    private void updateUI() {

    //详细的更新
    }

  有关Java以及Android的线程，我们将在以后的内容中介绍到，本次相关内容讲到这些，以后我们会告诉大家一些线程同步以及死锁问题的解决方法，总体而言感觉相对于Windows Mobile平台，Android上的线程消耗过大，而Symbian的活动对象又相对保守，总的而言Android线程相对简单


在分析Android消息机制之前，我们先来看一段代码： 

[html] view plaincopyprint?

1. public class MainActivity extends Activity implements View.OnClickListener {  
2.       
3.     private TextView stateText;  
4.     private Button btn;  
5.       
6.     @Override  
7.     public void onCreate(Bundle savedInstanceState) {  
8.         super.onCreate(savedInstanceState);  
9.         setContentView(R.layout.main);  
10.         stateText = (TextView) findViewById(R.id.tv);  
11.         btn = (Button) findViewById(R.id.btn);  
12.           
13.         btn.setOnClickListener(this);  
14.     }  
15.   
16.     @Override  
17.     public void onClick(View v) {  
18.         new WorkThread().start();  
19.     }  
20.       
21.     //工作线程  
22.     private class WorkThread extends Thread {  
23.         @Override  
24.         public void run() {  
25.             //......处理比较耗时的操作  
26.               
27.             //处理完成后改变状态  
28.             stateText.setText("completed");  
29.         }  
30.     }  
31. }  

这段代码似乎看上去很正常，但是当你运行时就会发现，它会报一个致命性的异常：

[html] view plaincopyprint?

1. ERROR/AndroidRuntime(421): FATAL EXCEPTION: Thread-8  
2. ERROR/AndroidRuntime(421): android.view.ViewRoot$CalledFromWrongThreadException:   
3. Only the original thread that created a view hierarchy can touch its views.  

 

到底是怎么回事呢？原因在于，Android系统中的视图组件并不是线程安全的，如果要更新视图，必须在主线程中更新，不可以在子线程中执行更新的操作。

既然这样，我们就在子线程中通知主线程，让主线程做更新操作吧。那么，我们如何通知主线程呢？我们需要使用到Handler对象。

我们稍微修改一下上面的代码：

[html] view plaincopyprint?

1. public class MainActivity extends Activity implements View.OnClickListener {  
2.       
3.     private static final int COMPLETED = 0;  
4.       
5.     private TextView stateText;  
6.     private Button btn;  
7.       
8.     private Handler handler = new Handler() {  
9.         @Override  
10.         public void handleMessage(Message msg) {  
11.             if (msg.what == COMPLETED) {  
12.                 stateText.setText("completed");  
13.             }  
14.         }  
15.     };  
16.       
17.     @Override  
18.     public void onCreate(Bundle savedInstanceState) {  
19.         super.onCreate(savedInstanceState);  
20.         setContentView(R.layout.main);  
21.         stateText = (TextView) findViewById(R.id.tv);  
22.         btn = (Button) findViewById(R.id.btn);  
23.           
24.         btn.setOnClickListener(this);  
25.     }  
26.   
27.     @Override  
28.     public void onClick(View v) {  
29.         new WorkThread().start();  
30.     }  
31.       
32.     //工作线程  
33.     private class WorkThread extends Thread {  
34.         @Override  
35.         public void run() {  
36.             //......处理比较耗时的操作  
37.               
38.             //处理完成后给handler发送消息  
39.             Message msg = new Message();  
40.             msg.what = COMPLETED;  
41.             handler.sendMessage(msg);  
42.         }  
43.     }  
44. }  

 

通过上面这种方式，我们就可以解决线程安全的问题，把复杂的任务处理工作交给子线程去完成，然后子线程通过handler对象告知主线程，由主线程更新视图，这个过程中消息机制起着重要的作用。

下面，我们就来分析一下Android中的消息机制。

熟悉Windows编程的朋友知道Windows程序是消息驱动的，并且有全局的消息循环系统。Google参考了Windows的消息循环机制，也在Android系统中实现了消息循环机制。Android通过Looper、Handler来实现消息循环机制。Android的消息循环是针对线程的，每个线程都可以有自己的消息队列和消息循环。

Android系统中的Looper负责管理线程的消息队列和消息循环。通过Looper.myLooper()得到当前线程的Looper对象，通过Looper.getMainLooper()得到当前进程的主线程的Looper对象。

前面提到，Android的消息队列和消息循环都是针对具体线程的，一个线程可以存在一个消息队列和消息循环，特定线程的消息只能分发给本线程，不能跨线程和跨进程通讯。但是创建的工作线程默认是没有消息队列和消息循环的，如果想让工作线程具有消息队列和消息循环，就需要在线程中先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。下面是我们创建的工作线程：

[html] view plaincopyprint?

1. class WorkThread extends Thread {  
2.       public Handler mHandler;  
3.   
4.       public void run() {  
5.           Looper.prepare();  
6.   
7.           mHandler = new Handler() {  
8.               public void handleMessage(Message msg) {  
9.                   // 处理收到的消息  
10.               }  
11.           };  
12.   
13.           Looper.loop();  
14.       }  
15.   }  

 

这样一来，我们创建的工作线程就具有了消息处理机制了。

那么，为什么前边的示例中，我们怎么没有看到Looper.prepare()和Looper.loop()的调用呢？原因在于，我们的Activity是一个UI线程，运行在主线程中，Android系统会在Activity启动时为其创建一个消息队列和消息循环。

前面提到最多的是消息队列(MessageQueue)和消息循环(Looper)，但是我们看到每个消息处理的地方都有Handler的存在，它是做什么的呢？Handler的作用是把消息加入特定的Looper所管理的消息队列中，并分发和处理该消息队列中的消息。构造Handler的时候可以指定一个Looper对象，如果不指定则利用当前线程的Looper对象创建。下面是Handler的两个构造方法：

[html] view plaincopyprint?

1. /**  
2.      * Default constructor associates this handler with the queue for the  
3.      * current thread.  
4.      *  
5.      * If there isn't one, this handler won't be able to receive messages.  
6.      */  
7.     public Handler() {  
8.         if (FIND_POTENTIAL_LEAKS) {  
9.             final Class<? extends Handler> klass = getClass();  
10.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
11.                     (klass.getModifiers() & Modifier.STATIC) == 0) {  
12.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
13.                     klass.getCanonicalName());  
14.             }  
15.         }  
16.   
17.         mLooper = Looper.myLooper();  
18.         if (mLooper == null) {  
19.             throw new RuntimeException(  
20.                 "Can't create handler inside thread that has not called Looper.prepare()");  
21.         }  
22.         mQueue = mLooper.mQueue;  
23.         mCallback = null;  
24.     }  
25.   
26. /**  
27.      * Use the provided queue instead of the default one.  
28.      */  
29.     public Handler(Looper looper) {  
30.         mLooper = looper;  
31.         mQueue = looper.mQueue;  
32.         mCallback = null;  
33.     }  

 

下面是消息机制中几个重要成员的关系图：

一个Activity中可以创建出多个工作线程，如果这些线程把他们消息放入Activity主线程的消息队列中，那么消息就会在主线程中处理了。因为主线程一般负责视图组件的更新操作，对于不是线程安全的视图组件来说，这种方式能够很好的实现视图的更新。

那么，子线程如何把消息放入主线程的消息队列中呢？只要Handler对象以主线程的Looper创建，那么当调用Handler的sendMessage方法，系统就会把消息主线程的消息队列，并且将会在调用handleMessage方法时处理主线程消息队列中的消息。

对于子线程访问主线程的Handler对象，你可能会问，多个子线程都访问主线程的Handler对象，发送消息和处理消息的过程中会不会出现数据的不一致呢？答案是Handler对象不会出现问题，因为Handler对象管理的Looper对象是线程安全的，不管是添加消息到消息队列还是从消息队列中读取消息都是同步保护的，所以不会出现数据不一致现象。

深入理解Android消息处理机制对于应用程序开发非常重要，也可以让我们对线程同步有更加深刻的认识，希望这篇文章可以对朋友们有所帮助。