Android中对Handle机制的理解

同线程不同组件之间的消息传递： 

[java]  view plain  copy

 print ?

1. public class Activity1 extends Activity implements OnClickListener{   
2.        Button button = null;   
3.        TextView text = null;   
4.        @Override   
5.        protected void onCreate(Bundle savedInstanceState) {   
6.               super.onCreate(savedInstanceState);   
7.               setContentView(R.layout.activity1);           
8.               button = (Button)findViewById(R.id.btn);   
9.               button.setOnClickListener(this);   
10.               text = (TextView)findViewById(R.id.content);   
11.        }   
12.        public void onClick(View v) {   
13.               switch (v.getId()) {   
14.               case R.id.btn: //组件1  
15.                      Looper looper = Looper.myLooper();//取得当前线程里的looper   
16.                      MyHandler mHandler = new MyHandler(looper);//构造一个handler使之可与looper通信  
17.                      //buton等组件可以由mHandler将消息传给looper后,再放入messageQueue中,同时mHandler也可以接受来自looper消息  
18.                      mHandler.removeMessages(0);   
19.                      String msgStr = "主线程不同组件通信:消息来自button";   
20.                      Message m = mHandler.obtainMessage(1, 1, 1, msgStr);//构造要传递的消息  
21.                      mHandler.sendMessage(m);//发送消息:系统会自动调用handleMessage方法来处理消息   
22.                      break;   
23.   
24.   
25.               }               
26.        }        
27.        private class MyHandler extends Handler{                
28.               public MyHandler(Looper looper){   
29.                      super(looper);   
30.               }   
31.               @Override   
32.               public void handleMessage(Message msg) {//处理消息   
33.                      text.setText(msg.obj.toString()); //组件2  
34.               }               
35.        }   
36. }   

说明： 
此程序启动时，当前线程(即主线程, main thread)已诞生了一个Looper对象，并且有了一个MessageQueue数据结构。 
    looper = Looper.myLooper ();  

调用Looper类别的静态myLooper()函数，以取得目前线程里的Looper对象. 

mHandler = new MyHandler (looper); 

构造一个MyHandler对象来与Looper沟通。Activity等对象可以藉由MyHandler对象来将消息传给Looper，然后放入MessageQueue里；MyHandler对象也扮演Listener的角色，可接收Looper对象所送来的消息。
Message m = mHandler.obtainMessage(1, 1, 1, obj); 

先构造一个Message对象，并将数据存入对象里。 
mHandler.sendMessage(m); 

就透过mHandler对象而将消息m传给Looper，然后放入MessageQueue里。 
此时，Looper对象看到MessageQueue里有消息m，就将它广播出去，mHandler对象接到此讯息时，会呼叫其handleMessage()函数来处理，于是输出"This my message!"于画面上，



2、Android消息机制二 
   http://xtfncel.javaeye.com/blog/663518

Android消息处理机制(二)

[java]  view plain  copy

 print ?

1. 子线程传递消息给主线程  
2.   
3. publicclass Activity2extends Activityimplements OnClickListener{  
4.   
5.        Button button =null;  
6.   
7.        TextView text =null;  
8.   
9.        MyHandler mHandler = null;  
10.   
11.        Thread thread ;  
12.   
13.        @Override  
14.   
15.        protectedvoid onCreate(Bundle savedInstanceState) {  
16.   
17.               super.onCreate(savedInstanceState);  
18.   
19.               setContentView(R.layout.activity1);          
20.   
21.               button = (Button)findViewById(R.id.btn);  
22.   
23.               button.setOnClickListener(this);  
24.   
25.               text = (TextView)findViewById(R.id.content);  
26.   
27.        }  
28.   
29.        publicvoid onClick(View v) {  
30.   
31.               switch (v.getId()) {  
32.   
33.               case R.id.btn:  
34.   
35.                      thread =new MyThread();  
36.   
37.                      thread.start();  
38.   
39.                      break;  
40.   
41.               }              
42.   
43.        }       
44.   
45.        privateclass MyHandlerextends Handler{               
46.   
47.               public MyHandler(Looper looper){  
48.   
49.                      super(looper);  
50.   
51.               }  
52.   
53.               @Override  
54.   
55.               publicvoid handleMessage(Message msg) {//处理消息  
56.   
57.                      text.setText(msg.obj.toString());  
58.   
59.               }              
60.   
61.        }  
62.   
63.        privateclass MyThreadextends Thread{  
64.   
65.               @Override  
66.   
67.               publicvoid run() {  
68.   
69.                      Looper curLooper = Looper.myLooper();  
70.   
71.                      Looper mainLooper = Looper.getMainLooper();  
72.   
73.                      String msg ;  
74.   
75.                      if(curLooper==null){  
76.   
77.                             mHandler =new MyHandler(mainLooper);  
78.   
79.                             msg = "curLooper is null";  
80.   
81.                      }else{  
82.   
83.                             mHandler =new MyHandler(curLooper);  
84.   
85.                             msg = "This is curLooper";  
86.   
87.                      }  
88.   
89.                      mHandler.removeMessages(0);  
90.   
91.                      Message m = mHandler.obtainMessage(1, 1, 1, msg);  
92.   
93.                      mHandler.sendMessage(m);  
94.   
95.               }              
96.   
97.        }  
98.   
99. }  

3、Android线程间通信的message机制 
   http://www.javafun.cn/viewthread.php?tid=15174、

在Android下面也有多线程的概念，在C/C++中，子线程可以是一个函数，一般都是一个带有循环的函数，来处理某些数据，优先线程只是一个复杂的运算过程，所以可能不需要while循环，运算完成，函数结束，线程就销毁。对于那些需要控制的线程，一般我们都是和互斥锁相互关联，从而来控制线程的进度，一般我们创建子线程，一种线程是很常见的，那就是带有消息循环的线程。
消息循环是一个很有用的线程方式，曾经自己用C在Linux下面实现一个消息循环的机制，往消息队列里添加数据，然后异步的等待消息的返回。当消息队列为空的时候就会挂起线程，等待新的消息的加入。这是一个很通用的机制。
在Android，这里的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper，这个事android的新概念。我们的主线程（UI线程）就是一个消息循环的线程。针对这种消息循环的机制，我们引入一个新的机制Handle，我们有消息循环，就要往消息循环里面发送相应的消息，自定义消息一般都会有自己对应的处理，消息的发送和清除，消息的的处理，把这些都封装在Handle里面，注意Handle只是针对那些有Looper的线程，不管是UI线程还是子线程，只要你有Looper，我就可以往你的消息队列里面添加东西，并做相应的处理。
但是这里还有一点，就是只要是关于UI相关的东西，就不能放在子线程中，因为子线程是不能操作UI的，只能进行数据、系统等其他非UI的操作。
那么什么情况下面我们的子线程才能看做是一个有Looper的线程呢？我们如何得到它Looper的句柄呢？
Looper.myLooper();获得当前的Looper
Looper.getMainLooper () 获得UI线程的Lopper
我们看看Handle的初始化函数，如果没有参数，那么他就默认使用的是当前的Looper，如果有Looper参数，就是用对应的线程的Looper。
如果一个线程中调用Looper.prepare()，那么系统就会自动的为该线程建立一个消息队列，然后调用 Looper.loop();之后就进入了消息循环，这个之后就可以发消息、取消息、和处理消息。这个如何发送消息和如何处理消息可以再其他的线程中通过Handle来做，但前提是我们的Hanle知道这个子线程的Looper，但是你如果不是在子线程运行 Looper.myLooper()，一般是得不到子线程的looper的。

[java]  view plain  copy

 print ?

1. public void run() {  
2.             synchronized (mLock) {  
3.                 Looper.prepare();  
4.                //do something  
5.             }  
6.             Looper.loop();  
7.         }  

[java]  view plain  copy

 print ?

1. class myThread extends Thread{  
2.              private EHandler mHandler ;  
3.              public void run() {  
4.                  Looper myLooper, mainLooper;  
5.                  myLooper = Looper.myLooper ();  
6.                 mainLooper = Looper.getMainLooper ();  
7.                 String obj;  
8.                 if (myLooper == null ){  
9.                          mHandler = new EHandler(mainLooper);  
10.                          obj = "current thread has no looper!" ;  
11.                 }  
12.                 else {  
13.                      mHandler = new EHandler(myLooper);  
14.                      obj = "This is from current thread." ;  
15.                 }  
16.                 mHandler .removeMessages(0);  
17.                 Message m = mHandler .obtainMessage(1, 1, 1, obj);  
18.                 mHandler .sendMessage(m);  
19.              }  
20.   }  

[java]  view plain  copy

 print ?

1. mAlbumArtWorker = new Worker("album art worker");  
2.         mAlbumArtHandler = new AlbumArtHandler(mAlbumArtWorker.getLooper());  

[java]  view plain  copy

 print ?

1. private class Worker implements Runnable {  
2.         private final Object mLock = new Object();  
3.         private Looper mLooper;  
4.           
5.         /** 
6.          * Creates a worker thread with the given name. The thread 
7.          * then runs a [email=%7B@link]{@link[/email] android.os.Looper}. 
8.          * @param name A name for the new thread 
9.          */  
10.         Worker(String name) {  
11.             Thread t = new Thread(null, this, name);  
12.             t.setPriority(Thread.MIN_PRIORITY);  
13.             t.start();  
14.             synchronized (mLock) {  
15.                 while (mLooper == null) {  
16.                     try {  
17.                         mLock.wait();  
18.                     } catch (InterruptedException ex) {  
19.                     }  
20.                 }  
21.             }  
22.         }  
23.           
24.         public Looper getLooper() {  
25.             return mLooper;  
26.         }  
27.           
28.         public void run() {  
29.             synchronized (mLock) {  
30.                 Looper.prepare();  
31.                 mLooper = Looper.myLooper();  
32.                 mLock.notifyAll();  
33.             }  
34.             Looper.loop();  
35.         }  
36.           
37.         public void quit() {  
38.             mLooper.quit();  
39.         }  
40.     }  

[java]  view plain  copy

 print ?

1. synchronized (mLock) {  
2.                 while (mLooper == null) {  
3.                     try {  
4.                         mLock.wait();  
5.                     } catch (InterruptedException ex) {  
6.                     }  
7.                 }  
8.             }  

我们开始等待我们的子线程给mLooper赋值，如果不赋值我们就继续等，然后我们的子线程在运行run方法之后，在给 mLooper赋值之后，通知worker够着函数中的wait，然后我们的构造函数才能完成，所以我们说：
mAlbumArtWorker = new Worker("album art worker");
这句本身就是阻塞的，它创建了一个子线程，开启了子线程，并且等待子线程给mLooper赋值，赋值完成之后，这个函数才返回，这样才能保证我们的子线程的Looper的获取绝对是正确的，这个构思很有创意。值得借鉴<!--++ plugin_code qcomic begin--> <!--++ plugin_code qcomic end--> 

4、Android中Handler的使用方法-在子线程中更新界面 

二、知识要点 
一、知识点 
1、handler应该由处理消息的线程创建。 

2、handler与创建它的线程相关联，而且也只与创建它的线程相关联。handler运行在创建它的线程中，所以，如果在handler中进行耗时的操作，会阻塞创建它的线程。
【来源】以上来自： 
二、一些知识点 
1、Android的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper。主线程（UI线程）就是一个消息循环的线程。

2、 
Looper.myLooper();      //获得当前的Looper 
Looper.getMainLooper () //获得UI线程的Lopper 

3、Handle的初始化函数（构造函数），如果没有参数，那么他就默认使用的是当前的Looper，如果有Looper参数，就是用对应的线程的Looper。

4、如果一个线程中调用Looper.prepare()，那么系统就会自动的为该线程建立一个消息队列，然后调用 Looper.loop();之后就进入了消息循环，这个之后就可以发消息、取消息、和处理消息。【来源】以上来自：http://www.javafun.cn/viewthread.PHP?tid=1517

三、应用实例 
3.1 handler传递message【应用示例一】 

[java]  view plain  copy

 print ?

1. package com.android.tutor;    
2. import java.util.Timer;    
3. import java.util.TimerTask;    
4. import android.app.Activity;    
5. import android.os.Bundle;    
6. import android.os.Handler;    
7. import android.os.Message;    
8. public class HandlerDemo extends Activity {    
9.         
10.     //title为setTitle方法提供变量,这里为了方便我设置成了int型    
11.     private int title = 0;    
12.         
13.     private Handler mHandler = new Handler(){             
14.         public void handleMessage(Message msg) {    
15.             switch (msg.what) {    
16.             case 1:    
17.                 updateTitle();    
18.                 break;    
19.             }    
20.         };    
21.     };    
22.     public void onCreate(Bundle savedInstanceState) {    
23.         super.onCreate(savedInstanceState);    
24.         setContentView(R.layout.main);    
25.             
26.         Timer timer = new Timer();    
27.         timer.scheduleAtFixedRate(new MyTask(), 1, 5000);    
28.     }    
29.             
30.     private class MyTask extends TimerTask{    
31.         @Override    
32.         public void run() {    
33.                 
34.             Message message = new Message();    
35.             message.what = 1;    
36.            mHandler.sendMessage(message);                 
37.         }       
38.     }    
39.         
40.         
41.     public void updateTitle(){    
42.             
43.         setTitle("Welcome to Mr Wei's blog " + title);    
44.         title ++;    
45.     }    
46. }    

3、在子线程中使用Handler对象post(runnable)对象.

转载：http://blog.csdn.net/chaoyu168/article/details/50913941