雾山的Android学习笔记---消息机制（三） .

从Main Thread 向Worker Thread发送消息总共分成三个步骤：

1，准备Looper对象

2，在Worker Thread当中生成Handler对象

3，在Main Thread当中发送消息

下面举个例子来说明：

开发步骤： 
1，新建一个Android应用程序 
2，在布局文件中添加一个Button控件标签，并为其设置属性和值 
3，在Activity中，声明Button控件变量并根据id获得控件对象 ，设置该Button的监听器，
4，在Activity中，创建一个Thread的继承类WorkerThread，并重写run（）方法 
5，在Activity中，创建一个Handler的继承类MyHandler，并重写handleMessage()方法 

代码如下：

[java] view plain copy print ?

1. package com.example.s02e07_handler03;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.os.Handler;  
6. import android.os.Looper;  
7. import android.os.Message;  
8. import android.view.Menu;  
9. import android.view.View;  
10. import android.view.View.OnClickListener;  
11. import android.widget.Button;  
12.   
13. public class MainActivity extends Activity {  
14.     private Button button;  
15.     private Handler handler;  
16.   
17.     @Override  
18.     protected void onCreate(Bundle savedInstanceState) {  
19.         super.onCreate(savedInstanceState);  
20.         setContentView(R.layout.activity_main);  
21.           
22.         button = (Button)findViewById(R.id.button);  
23.           
24.         button.setOnClickListener(new ButtonListener());  
25.         WorkerThread wt = new WorkerThread();  
26.         wt.start();  
27.     }  
28.       
29.     class ButtonListener implements OnClickListener{  
30.   
31.         @Override  
32.         public void onClick(View v) {  
33.             Message msg = handler.obtainMessage();  
34.             handler.sendMessage(msg);  
35.         }  
36.     }  
37.       
38.     class WorkerThread extends Thread{  
39.   
40.         @Override  
41.         public void run() {  
42.             //准备Looper对象   
43.             Looper.prepare();  
44.             //在workThread当中生成一个Handler对象   
45.             handler = new MyHandler();  
46.             //也可以用匿名内部类的方法实现   
47. //          handler = new Handler(){   
48. //              @Override   
49. //              public void handleMessage(Message msg){   
50. //                  System.out.println("收到");   
51. //              }   
52. //          };   
53.             //调用Looper的loop（）方法之后，Looper对象将不断的从消息队列中取出消息对象，然后调用handlerMessage（）方法处理该消息对象   
54.             //如果消息队列中没有对象，则该线程阻塞   
55.             Looper.loop();  
56.               
57.         }  
58.     }  
59.       
60.     class MyHandler  extends Handler{  
61.   
62.         @Override  
63.         public void handleMessage(Message msg) {  
64.             System.out.println("收到");  
65.         }  
66.     }  
67.   
68.     @Override  
69.     public boolean onCreateOptionsMenu(Menu menu) {  
70.         // Inflate the menu; this adds items to the action bar if it is present.   
71.         getMenuInflater().inflate(R.menu.main, menu);  
72.         return true;  
73.     }  
74.   
75. }  

package com.example.s02e07_handler03;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {
	private Button button;
	private Handler handler;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		button = (Button)findViewById(R.id.button);
		
		button.setOnClickListener(new ButtonListener());
		WorkerThread wt = new WorkerThread();
		wt.start();
	}
	
	class ButtonListener implements OnClickListener{

		@Override
		public void onClick(View v) {
			Message msg = handler.obtainMessage();
			handler.sendMessage(msg);
		}
	}
	
	class WorkerThread extends Thread{

		@Override
		public void run() {
			//准备Looper对象
			Looper.prepare();
			//在workThread当中生成一个Handler对象
			handler = new MyHandler();
			//也可以用匿名内部类的方法实现
//			handler = new Handler(){
//				@Override
//				public void handleMessage(Message msg){
//					System.out.println("收到");
//				}
//			};
			//调用Looper的loop（）方法之后，Looper对象将不断的从消息队列中取出消息对象，然后调用handlerMessage（）方法处理该消息对象
			//如果消息队列中没有对象，则该线程阻塞
			Looper.loop();
			
		}
	}
	
	class MyHandler  extends Handler{

		@Override
		public void handleMessage(Message msg) {
			System.out.println("收到");
		}
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.main, menu);
		return true;
	}

}

当运行程序时：

1，会在Main Thread中运行一个Work Thread 线程wt

2，wt调用Looper的loop（）方法之后，Looper对象将不断的从消息队列中取出消息对象

3，当点击button后，会向消息队列中发送一个消息对象msg，此时会被Work Thread中的Looper对象从消息队列取出，然后调用handlerMessage（）方法处理该消息对象

这样就完成了从Main Thread向Work Thread发送信息的过程。