Android之Message机制的灵活应用

最新推荐文章于 2024-05-02 20:40:27 发布

YAnG_Linux

最新推荐文章于 2024-05-02 20:40:27 发布

阅读量1.3k

点赞数

分类专栏： Android 文章标签： android thread import string button callback

Android 专栏收录该内容

167 篇文章 1 订阅

订阅专栏

　　程序代码如下，后面部分有代码说明：

　1　package　com.android.messageexample;　　
　2　import　android.app.Activity;　　
　3　import　android.content.Context;　　
　4　import　android.graphics.Color;　　
　5　import　android.os.Bundle;　　
　6　import　android.os.Handler;　　
　7　import　android.os.Looper;　　
　8　import　android.os.Message;　　
　9　import　android.util.Log;　　
　10　import　android.view.View;　　
　11　import　android.view.View.OnClickListener;　　
　12　import　android.widget.Button;　　
　13　import　android.widget.LinearLayout;　　
　14　import　android.widget.TextView;　　
　15　　public　class　MessageExample　extends　Activity　implements　OnClickListener　{　　
　16　private　final　int　WC　=　LinearLayout.LayoutParams.WRAP_CONTENT;　　
　17　private　final　int　FP　=　LinearLayout.LayoutParams.FILL_PARENT;　　
　18　public　TextView　tv;　　
　19　private　EventHandler　mHandler;　　
　20　private　Handler　mOtherThreadHandler=null;　　
　21　private　Button　btn,　btn2,　btn3,　btn4,　btn5,　btn6;　　
　22　private　NoLooperThread　noLooerThread　=　null;　　
　23　private　OwnLooperThread　ownLooperThread　=　null;　　
　24　private　ReceiveMessageThread　receiveMessageThread　=null;　　
　25　private　Context　context　=　null;　　
　26　private　final　String　sTag　=　"MessageExample";　　
　27　private　boolean　postRunnable　=　false;　　
　28　　
　29　/**　Called　when　the　activity　is　first　created.　*/　
　30　@Override　
　31　public　void　onCreate(Bundle　savedInstanceState)　{　　
　32　　　　super.onCreate(savedInstanceState);　　
　33　　　　context　=　this.getApplicationContext();　　
　34　　　　LinearLayout　layout　=　new　LinearLayout(this);　　
　35　　　　layout.setOrientation(LinearLayout.VERTICAL);　　
　36　　　　btn　=　new　Button(this);　　
　37　　　　btn.setId(101);　　
　38　　　　btn.setText("message　from　main　thread　self");　　
　39　　　　btn.setOnClickListener(this);　　
　40　　　　LinearLayout.LayoutParams　param　=　　
　41　　　　　new　LinearLayout.LayoutParams(250,50);　　
　42　　　　param.topMargin　=　10;　　
　43　　　　layout.addView(btn,　param);　　
　44　　　　btn2　=　new　Button(this);　　
　45　　　　btn2.setId(102);　　
　46　　　　btn2.setText("message　from　other　thread　to　main　thread");　　
　47　　　　btn2.setOnClickListener(this);　　
　48　　　　layout.addView(btn2,　param);　　
　49　　　　btn3　=　new　Button(this);　　
　50　　　　btn3.setId(103);　　
　51　　　　btn3.setText("message　to　other　thread　from　itself");　　
　52　　　　btn3.setOnClickListener(this);　　
　53　　　　layout.addView(btn3,　param);　　
　54　　　　btn4　=　new　Button(this);　　
　55　　　　btn4.setId(104);　　
　56　　　　btn4.setText("message　with　Runnable　as　callback　from　other　thread　to　main　thread");　　
　57　　　　btn4.setOnClickListener(this);　　
　58　　　　layout.addView(btn4,　param);　　
　59　　　　btn5　=　new　Button(this);　　
　60　　　　btn5.setId(105);　　
　61　　　　btn5.setText("main　thread's　message　to　other　thread");　　
　62　　　　btn5.setOnClickListener(this);　　
　63　　　　layout.addView(btn5,　param);　　
　64　　　　btn6　=　new　Button(this);　　
　65　　　　btn6.setId(106);　　
　66　　　　btn6.setText("exit");　　
　67　　　　btn6.setOnClickListener(this);　　
　68　　　　layout.addView(btn6,　param);　　
　69　　　　tv　=　new　TextView(this);　　
　70　　　　tv.setTextColor(Color.WHITE);　　
　71　　　　tv.setText("");　　
　72　　　　LinearLayout.LayoutParams　param2　=　　
　73　　　　　　new　LinearLayout.LayoutParams(FP,　WC);　　
　74　　　　param2.topMargin　=　10;　　
　75　　　　layout.addView(tv,　param2);　　
　76　　　　setContentView(layout);　　　　
　77　　　　　
　78　　　　//主线程要发送消息给other　thread，　这里创建那个other　thread　　
　79　　receiveMessageThread　=　new　ReceiveMessageThread();　　
　80　　receiveMessageThread.start();　　
　81　}　　
　82　　
　83　//implement　the　OnClickListener　interface　　
　84　@Override　
　85　public　void　onClick(View　v)　{　　
　86　　switch(v.getId()){　　
　87　　case　101:　　
　88　//主线程发送消息给自己　　
　89　Looper　looper;　　
　90　looper　=　Looper.myLooper();　　//get　the　Main　looper　related　with　the　main　thread　　
　91　//如果不给任何参数的话会用当前线程对应的Looper(这里就是Main　Looper)为Handler里面的成员mLooper赋值　　
　92　mHandler　=　new　EventHandler(looper);　　
　93　//mHandler　=　new　EventHandler();　　
　94　//　清除整个MessageQueue里的消息　　
　95　mHandler.removeMessages(0);　　
　96　String　obj　=　"This　main　thread's　message　and　received　by　itself!";　　
　97　//得到Message对象　　
　98　Message　m　=　mHandler.obtainMessage(1,　1,　1,　obj);　　
　99　//　将Message对象送入到main　thread的MessageQueue里面　　
100　mHandler.sendMessage(m);　　
101　break;　　
102　　case　102:　　
103　//other线程发送消息给主线程　　
104　postRunnable　=　false;　　
105　noLooerThread　=　new　NoLooperThread();　　
106　noLooerThread.start();　　
107　break;　　
108　　case　103:　　　
109　//other　thread获取它自己发送的消息　　
110　tv.setText("please　look　at　the　error　level　log　for　other　thread　received　message");　　
111　ownLooperThread　=　new　OwnLooperThread();　　
112　ownLooperThread.start();　　
113　break;　　
114　　case　104:　　　　
115　//other　thread通过Post　Runnable方式发送消息给主线程　　
116　postRunnable　=　true;　　
117　noLooerThread　=　new　NoLooperThread();　　
118　noLooerThread.start();　　
119　break;　　
120　　case　105:　　　　
121　//主线程发送消息给other　thread　　
122　if(null!=mOtherThreadHandler){　　
123　tv.setText("please　look　at　the　error　level　log　for　other　thread　received　message　from　main　thread");　　
124　String　msgObj　=　"message　from　mainThread";　　
125　Message　mainThreadMsg　=　mOtherThreadHandler.obtainMessage(1,　1,　1,　msgObj);　　
126　mOtherThreadHandler.sendMessage(mainThreadMsg);　　
127　}　　
128　break;　　
129　　case　106:　　
130　finish();　　
131　break;　　
132　　}　　
133　}　　
134　class　EventHandler　extends　Handler　　
135　{　　
136　　public　EventHandler(Looper　looper)　{　　
137　super(looper);　　
138　　}　　
139　　public　EventHandler()　{　　
140　super();　　
141　　}　　
142　　public　void　handleMessage(Message　msg)　{　　
143　//可以根据msg.what执行不同的处理，这里没有这么做　　
144　switch(msg.what){　　
145　case　1:　　
146　tv.setText((String)msg.obj);　　
147　break;　　
148　case　2:　　
149　tv.setText((String)msg.obj);　　
150　noLooerThread.stop();　　
151　break;　　
152　case　3:　　
153　//不能在非主线程的线程里面更新UI，所以这里通过Log打印收到的消息　　
154　Log.e(sTag,　(String)msg.obj);　　
155　ownLooperThread.stop();　　
156　break;　　
157　default:　　
158　//不能在非主线程的线程里面更新UI，所以这里通过Log打印收到的消息　　
159　Log.e(sTag,　(String)msg.obj);　　
160　break;　　
161　}　　
162　　}　　
163　}　　
164　//NoLooperThread　　
165　class　NoLooperThread　extends　Thread{　　
166　　private　EventHandler　mNoLooperThreadHandler;　　
167　　public　void　run()　{　　
168　Looper　myLooper,　mainLooper;　　
169　myLooper　=　Looper.myLooper();　　
170　mainLooper　=　Looper.getMainLooper();　//这是一个static函数　　
171　String　obj;　　
172　if(myLooper　==　null){　　
173　mNoLooperThreadHandler　=　new　EventHandler(mainLooper);　　
174　obj　=　"NoLooperThread　has　no　looper　and　handleMessage　function　executed　in　main　thread!";　　
175　}　　
176　else　{　　
177　mNoLooperThreadHandler　=　new　EventHandler(myLooper);　　
178　obj　=　"This　is　from　NoLooperThread　self　and　handleMessage　function　executed　in　NoLooperThread!";　　
179　}　　
180　mNoLooperThreadHandler.removeMessages(0);　　
181　if(false　==　postRunnable){　　
182　//send　message　to　main　thread　　
183　Message　m　=　mNoLooperThreadHandler.obtainMessage(2,　1,　1,　obj);　　
184　mNoLooperThreadHandler.sendMessage(m);　　
185　Log.e(sTag,　"NoLooperThread　id:"　+　this.getId());　　
186　}else{　　
187　//下面new出来的实现了Runnable接口的对象中run函数是在Main　Thread中执行，不是在NoLooperThread中执行　　
188　//注意Runnable是一个接口，它里面的run函数被执行时不会再新建一个线程　　
189　//您可以在run上加断点然后在eclipse调试中看它在哪个线程中执行　　
190　mNoLooperThreadHandler.post(new　Runnable(){　　　
191　　　@Override　　　
192　　　public　void　run()　{　　　
193　　tv.setText("update　UI　through　handler　post　runnalbe　mechanism!");　　
194　　noLooerThread.stop();　　
195　　　}　　　
196　});　　　
197　}　　
198　　}　　
199　}　　
200　　
201　//OwnLooperThread　has　his　own　message　queue　by　execute　Looper.prepare();　　
202　class　OwnLooperThread　extends　Thread{　　
203　　private　EventHandler　mOwnLooperThreadHandler;　　
204　　public　void　run()　{　　
205　Looper.prepare();　　
206　Looper　myLooper,　mainLooper;　　
207　myLooper　=　Looper.myLooper();　　
208　mainLooper　=　Looper.getMainLooper();　//这是一个static函数　　
209　String　obj;　　
210　if(myLooper　==　null){　　
211　mOwnLooperThreadHandler　=　new　EventHandler(mainLooper);　　
212　obj　=　"OwnLooperThread　has　no　looper　and　handleMessage　function　executed　in　main　thread!";　　
213　}　　
214　else　{　　
215　mOwnLooperThreadHandler　=　new　EventHandler(myLooper);　　
216　obj　=　"This　is　from　OwnLooperThread　self　and　handleMessage　function　executed　in　NoLooperThread!";　　
217　}　　
218　mOwnLooperThreadHandler.removeMessages(0);　　
219　//给自己发送消息　　
220　Message　m　=　mOwnLooperThreadHandler.obtainMessage(3,　1,　1,　obj);　　
221　mOwnLooperThreadHandler.sendMessage(m);　　
222　Looper.loop();　　
223　　}　　
224　}　　
225　　
226　//ReceiveMessageThread　has　his　own　message　queue　by　execute　Looper.prepare();　　
227　class　ReceiveMessageThread　extends　Thread{　　
228　　public　void　run()　{　　
229　Looper.prepare();　　
230　mOtherThreadHandler　=　new　Handler(){　　
231　public　void　handleMessage(Message　msg)　{　　
232　　　Log.e(sTag,　(String)msg.obj);　　
233　}　　
234　};　　
235　Looper.loop();　　
236　　}　　
237　}　　
238　　
239　}　
240

EevntHandler(Looper.myLooper()); 可建立用来处理当前线程的Handler对象；其中，EevntHandler是Handler的子类。

　　使用mHandler = new EevntHandler(Looper.getMainLooper()); 可建立用来处理main线程的Handler对象；其中，EevntHandler是Handler的子类。

　　主线程发送消息：

　　在 onClick的case 101中创建一个继承自Handler的EventHandler对象，然后获取一个消息，然后通过EventHandler对象调用 sendMessage把消息发送到主线程的MessageQueue中。主线程由系统创建，系统会给它建立一个Looper对象和 MessageQueue，所以可以接收消息。这里只要根据主线程的Looper对象初始化EventHandler对象，就可以通过 EventHandler对象发送消息到主线程的消息队列中。

　　主线程处理消息：

　　这里是通过 EventHandler的handleMessage函数处理的，其中收到的Message对象中what值为一的消息就是发送给它的，然后把消息里面附带的字符串在TextView上显示出来。

　　其他线程发送消息（这里是说不使用Runnable作为callback的消息）：

　　首先 postRunnable设为false，表示不通过Runnable方式进行消息相关的操作。然后启动线程noLooerThread，然后以主线程的Looper对象为参数建立EventHandler的对象mNoLooperThreadHandler，然后获取一个Message并把一个字符串赋值给它的一个成员obj，然后通过mNoLooperThreadHandler把消息发送到主线程的MessageQueue中。

　　主线程处理消息：

　　这里是通过 EventHandler的handleMessage函数处理的，其中收到的Message对象中what值为二的消息就是上面发送给它的，然后把消息里面附带的字符串在TextView上显示出来。

　　其他线程发送消息：

　　其他非主线程建立后没有自己的Looper对象，所以也没有MessageQueue，需要给非主线程发送消息时需要建立MessageQueue以便接收消息。下面说明如何给自己建立MessageQueue和Looper对象。从OwnLooperThread的run函数中可以看见有一个 Looper.prepare()调用，这个就是用来建立非主线程的MessageQueue和Looper对象的。

　　所以这里的发送消息过程是建立线程mOwnLooperThread，然后线程建立自己的Looper和MessageQueue对象，然后根据上面建立的Looper对象建立对应的EventHandler对象mOwnLooperThreadHandler，然后由mOwnLooperThreadHandler建立消息并且发送到自己的MessageQueue里面。

　　其他线程处理接收的消息：

　　线程要接收消息需要在 run函数中调用Looper.loop()，然后loop函数会从MessageQueue中取出消息交给对应的Handler对象 mOwnLooperThreadHandler处理，在mOwnLooperThreadHandler的handleMessage函数中会把 Message对象中what值为三的消息（上面发送的消息）在Log中打印出来，可以通过Logcat工具查看log。

　　其他线程发送消息（这里是说使用Runnable作为callback的消息）：

　　首先 postRunnable设为true，表示通过Runnable方式进行消息相关的操作。然后启动线程noLooerThread，然后以主线程的Looper对象为参数建立EventHandler的对象mNoLooperThreadHandler，然后获取一个Message并把一个字符串赋值给它的一个成员obj，然后通过mNoLooperThreadHandler把消息发送到主线程的MessageQueue中。

　　主线程处理消息：

　　主线程收到上面发送的Message后直接运行上面Runnable对象中的run函数进行相应的操作。run函数通过Log打印一个字符串，可以通过Logcat工具查看 log。

　　主线程发送消息：

　　这里首先要求线程receiveMessageThread运行（在onCreate函数中完成），并且准备好自己的 Looper和MessageQueue（这个通过ReceiveMessageThread中的run函数中的Looper.prepare()调用完成），然后根据建立的Looper对象初始化Handler对象mOtherThreadHandler。然后在onClick的case 105中由mOtherThreadHandler建立一个消息（消息中有一个字符串对象）并且发送到线程receiveMessageThread中的 MessageQueue中。

　　其他线程处理接收的消息：

　　线程要接收消息需要在run函数中调用 Looper.loop()，然后loop函数会从MessageQueue中取出消息交给对应的Handler对象 mOtherThreadHandler处理，在mOtherThreadHandler的handleMessage函数中会把Message对象中的字符串对象在Log中打印出来，可以通过Logcat工具查看log

YAnG_Linux

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android之Message机制的灵活应用

程序代码如下，后面部分有代码说明：　1　package　com.android.messageexample;　　　2　import　android.app.Activity;　　　3　import　android.content.Context;　　　4　import　android.graphics.Color;　　　5　import　android.os.Bundle;　　　6
复制链接

扫一扫