handler使用2

Android中有关Handler的使用（二）

 

2、sendMessage版本的Handler的使用

 

     这里介绍几种模型:

 

a、默认的Handler（消息处理队列挂在主线程上）

[java]  view plain  copy

1. package com.dxyh.test;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.os.Handler;  
6. import android.os.Message;  
7. import android.util.Log;  
8. import android.view.View;  
9. import android.view.View.OnClickListener;  
10. import android.widget.Button;  
11.   
12. public class MainActivity extends Activity  
13.                   implements OnClickListener {  
14.     private final static String TAG = "HandlerTest";  
15.       
16.     private final static int TASK_BEGIN = 1;  
17.     private final static int TASK_1 = 2;  
18.     private final static int TASK_2 = 3;  
19.     private final static int TASK_END   = 4;  
20.       
21.     private Button btnStart = null;  
22.     private Button btnStop = null;  
23.       
24.     /** Called when the activity is first created. */  
25.     @Override  
26.     public void onCreate(Bundle savedInstanceState) {  
27.         super.onCreate(savedInstanceState);  
28.         setContentView(R.layout.main);  
29.           
30.         btnStart = (Button) findViewById(R.id.btn_start);  
31.         btnStart.setOnClickListener(this);  
32.         btnStop = (Button) findViewById(R.id.btn_stop);  
33.         btnStop.setOnClickListener(this);  
34.           
35.         Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]");  
36.     }  
37.       
38.     Handler mHandler = new Handler() {  
39.         // 注意：在各个case后面不能做太耗时的操作，否则出现ANR对话框  
40.         @Override  
41.         public void handleMessage(Message msg) {  
42.             switch (msg.what) {  
43.             case TASK_BEGIN:  
44.                 Log.i(TAG, "[H_TID:" +  
45.                     Thread.currentThread().getId() + "] Get TASK_BEGIN");  
46.                 break;  
47.                   
48.             case TASK_1:  
49.                 Log.i(TAG, "[H_TID:" +  
50.                     Thread.currentThread().getId() + "] Get TASK_1");  
51.                 break;  
52.                   
53.             case TASK_2:  
54.                 Log.i(TAG, "[H_TID:" +  
55.                     Thread.currentThread().getId() + "] Get TASK_2");  
56.                 break;  
57.                   
58.             case TASK_END:  
59.                 Log.i(TAG, "[H_TID:" +  
60.                     Thread.currentThread().getId() + "] Get TASK_END");  
61.                 finish();  
62.                 break;  
63.             }  
64.             super.handleMessage(msg);  
65.         }  
66.     };  
67.       
68.     public void onClick(View view) {  
69.         switch (view.getId()) {  
70.         case R.id.btn_start:  
71.             // 启动任务（消息只有标识，立即投递）  
72.             mHandler.sendEmptyMessage(TASK_BEGIN);  
73.             Log.i(TAG, "Send TASK_BEGIN to handler.");  
74.               
75.             // 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）  
76.             Message msg1 = mHandler.obtainMessage(TASK_1);  
77.             msg1.obj = "This is task1";  
78.             mHandler.sendMessage(msg1);  
79.             Log.i(TAG, "Send TASK_1 to handler.");  
80.               
81.             // 开启任务2（和上面类似）  
82.             Message msg2 = Message.obtain();  
83.             msg2.arg1 = 10;  
84.             msg2.arg2 = 20;  
85.             msg2.what = TASK_2;  
86.             mHandler.sendMessage(msg2);  
87.             Log.i(TAG, "Send TASK_2 to handler.");  
88.             break;  
89.               
90.         case R.id.btn_stop:  
91.             // 结束任务（空消息体，延时2s投递）  
92.             mHandler.sendEmptyMessageDelayed(TASK_END, 2000);  
93.             Log.i(TAG, "Send TASK_END to handler.");  
94.             break;  
95.         }  
96. }  
97. }  

运行结果：

 

b、消息队列仍绑定在主线程上，但在子线程中发送消息。

[java]  view plain  copy

1. package com.dxyh.test;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.os.Handler;  
6. import android.os.Message;  
7. import android.util.Log;  
8.   
9. public class MainActivity extends Activity {  
10.     private final static String TAG = "HandlerTest";  
11.       
12.     private final static int TASK_BEGIN = 1;  
13.     private final static int TASK_1 = 2;  
14.     private final static int TASK_2 = 3;  
15.     private final static int TASK_END   = 4;  
16.       
17.     /** Called when the activity is first created. */  
18.     @Override  
19.     public void onCreate(Bundle savedInstanceState) {  
20.         super.onCreate(savedInstanceState);  
21.         setContentView(R.layout.main);  
22.           
23.         Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +  
24.                 "This is in main thread.");  
25.           
26.         workThread.start();  
27.     }  
28.       
29.     Handler mHandler = new Handler() {  
30.         // 注意：在各个case后面不能做太耗时的操作，否则出现ANR对话框  
31.         @Override  
32.         public void handleMessage(Message msg) {  
33.             switch (msg.what) {  
34.             case TASK_BEGIN:  
35.                 Log.i(TAG, "[H_TID:" +  
36.                 Thread.currentThread().getId() + "] Get TASK_BEGIN");  
37.                 break;  
38.                   
39.             case TASK_1:  
40.                 Log.i(TAG, "[H_TID:" +  
41.                 Thread.currentThread().getId() + "] Get TASK_1");  
42.                 break;  
43.                   
44.             case TASK_2:  
45.                 Log.i(TAG, "[H_TID:" +  
46.                 Thread.currentThread().getId() + "] Get TASK_2");  
47.                 break;  
48.                   
49.             case TASK_END:  
50.                 Log.i(TAG, "[H_TID:" +  
51.                 Thread.currentThread().getId() + "] Get TASK_END");  
52.                 finish();  
53.                 break;  
54.             }  
55.             super.handleMessage(msg);  
56.         }  
57.     };  
58.       
59.     Thread workThread = new Thread() {  
60.         // 你可以在run方法内做任何耗时的操作，然后将结果以消息形式投递到主线程的消息队列中  
61.         @Override  
62.         public void run() {  
63.             // 启动任务（消息只有标识，立即投递）  
64.             mHandler.sendEmptyMessage(TASK_BEGIN);  
65.             Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +  
66.                     "Send TASK_START to handler.");  
67.               
68.             // 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）  
69.             Message msg1 = mHandler.obtainMessage(TASK_1);  
70.             msg1.obj = "This is task1";  
71.             mHandler.sendMessage(msg1);  
72.             Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +  
73.                     "Send TASK_1 to handler.");  
74.               
75.             // 开启任务2（和上面类似）  
76.             Message msg2 = Message.obtain();  
77.             msg2.arg1 = 10;  
78.             msg2.arg2 = 20;  
79.             msg2.what = TASK_2;  
80.             mHandler.sendMessage(msg2);  
81.             Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +  
82.                     "Send TASK_2 to handler.");  
83.               
84.             // 结束任务（空消息体，延时2s投递）  
85.             mHandler.sendEmptyMessageDelayed(TASK_END, 2000);  
86.             Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +  
87.                     "Send TASK_END to handler.");  
88.         }  
89.     };  
90. }  

运行结果：

c、将消息队列绑定到子线程上，主线程只管通过Handler往子线程的消息队列中投递消息即可。

[java]  view plain  copy

1. package com.dxyh.test;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5. import android.os.Handler;  
6. import android.os.HandlerThread;  
7. import android.os.Looper;  
8. import android.os.Message;  
9. import android.util.Log;  
10.   
11. public class MainActivity extends Activity {  
12.     private final static String TAG = "HandlerTest";  
13.       
14.     private final static int TASK_BEGIN = 1;  
15.     private final static int TASK_1 = 2;  
16.     private final static int TASK_2 = 3;  
17.     private final static int TASK_END   = 4;  
18.       
19.     private MyHandler mHandler = null;  
20.       
21.     /** Called when the activity is first created. */  
22.     @Override  
23.     public void onCreate(Bundle savedInstanceState) {  
24.         super.onCreate(savedInstanceState);  
25.         setContentView(R.layout.main);  
26.   
27.         Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +  
28.                 "This is in main thread.");  
29.           
30.         HandlerThread myLooperThread = new HandlerThread("my looper thread");  
31.         myLooperThread.start();  
32.           
33.         Looper looper = myLooperThread.getLooper();  
34.         mHandler = new MyHandler(looper);  
35.           
36.         // 启动任务（消息只有标识，立即投递）  
37.         mHandler.sendEmptyMessage(TASK_BEGIN);  
38.         Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
39.                 "Send TASK_START to handler.");  
40.           
41.         // 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）  
42.         Message msg1 = mHandler.obtainMessage(TASK_1);  
43.         msg1.obj = "This is task1";  
44.         mHandler.sendMessage(msg1);  
45.         Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
46.                 "Send TASK_1 to handler.");  
47.           
48.         // 开启任务2（和上面类似）  
49.         Message msg2 = Message.obtain();  
50.         msg2.arg1 = 10;  
51.         msg2.arg2 = 20;  
52.         msg2.what = TASK_2;  
53.         mHandler.sendMessage(msg2);  
54.         Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
55.                 "Send TASK_2 to handler.");  
56.           
57.         // 结束任务（空消息体，延时2s投递）  
58.         mHandler.sendEmptyMessageDelayed(TASK_END, 2000);  
59.         Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
60.                 "Send TASK_END to handler.");  
61.     }  
62.       
63.     class MyHandler extends Handler {  
64.         public MyHandler(Looper looper) {  
65.             super(looper);  
66.         }  
67.           
68.         // 现在在每个case之后，你可以做任何耗时的操作了  
69.         @Override  
70.         public void handleMessage(Message msg) {  
71.             switch (msg.what) {  
72.             case TASK_BEGIN:  
73.                 Log.i(TAG, "[H_TID:" +  
74.                     Thread.currentThread().getId() + "] Get TASK_BEGIN");  
75.                 break;  
76.                   
77.             case TASK_1:  
78.                 Log.i(TAG, "[H_TID:" +  
79.                     Thread.currentThread().getId() + "] Get TASK_1");  
80.                 break;  
81.                   
82.             case TASK_2:  
83.                 Log.i(TAG, "[H_TID:" +  
84.                     Thread.currentThread().getId() + "] Get TASK_2");  
85.                 break;  
86.                   
87.             case TASK_END:  
88.                 Log.i(TAG, "[H_TID:" +  
89.                     Thread.currentThread().getId() + "] Get TASK_END");  
90.                 finish();  
91.                 break;  
92.             }  
93.             super.handleMessage(msg);  
94.         }  
95.     }  
96. }  

运行结果：

 

[待续]