程序博客网 > 贵州卫计委网络直报

Handler（4）

来源：互联网 发布：贵州卫计委网络直报 编辑：程序博客网 时间：2024/06/04 17:48


d、自己创建新的线程，然后在新线程中创建Looper，主线程调用子线程中的发消息方法，将消息发给子线程的消息队列。

  

       方式1

  1. package com.dxyh.test; 
  2. import android.app.Activity;  
  3. import android.os.Bundle;  
  4. import android.os.Handler;  
  5. import android.os.Looper;  
  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.     private Handler workHandler = null;  
  18.       
  19.     /** Called when the activity is first created. */  
  20.     @Override  
  21.     public void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.main);  
  24.   
  25.         Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +  
  26.                 "This is in main thread.");  
  27.           
  28.         LooperThread testThread = new LooperThread();  
  29.         testThread.start();  
  30.           
  31.         // 注意，这里需要等待一下，防止出现空指针异常  
  32.         while (null == workHandler) {  
  33.         }  
  34.           
  35.         testThread.sendMessageTodoYourWork();  
  36.     }  
  37.       
  38.     class LooperThread extends Thread {  
  39.         @Override  
  40.         public void run() {  
  41.             Looper.prepare();  
  42.               
  43.             workHandler = new Handler() {  
  44.                 // 现在在每个case之后，你可以做任何耗时的操作了  
  45.                 @Override  
  46.                 public void handleMessage(Message msg) {  
  47.                     switch (msg.what) {  
  48.                     case TASK_BEGIN:  
  49.                         Log.i(TAG, "[H_TID:" +  
  50.                            Thread.currentThread().getId() + "] Get TASK_BEGIN");  
  51.                         break;  
  52.                           
  53.                     case TASK_1:  
  54.                         Log.i(TAG, "[H_TID:" +  
  55.                            Thread.currentThread().getId() + "] Get TASK_1");  
  56.                         break;  
  57.                           
  58.                     case TASK_2:  
  59.                         Log.i(TAG, "[H_TID:" +  
  60.                            Thread.currentThread().getId() + "] Get TASK_2");  
  61.                         break;  
  62.                           
  63.                     case TASK_END:  
  64.                         Log.i(TAG, "[H_TID:" +  
  65.                            Thread.currentThread().getId() + "] Get TASK_END");  
  66.                         Looper.myLooper().quit();  
  67.                         finish();  
  68.                         break;  
  69.                     }  
  70.                     super.handleMessage(msg);  
  71.                 }  
  72.             };  
  73.               
  74.             Looper.loop();  
  75.         }  
  76.           
  77.         public void sendMessageTodoYourWork() {  
  78.             Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
  79.                 "Send TASK_START to handler.");  
  80.             // 启动任务（消息只有标识，立即投递）  
  81.             workHandler.sendEmptyMessage(TASK_BEGIN);  
  82.   
  83.             Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
  84.                 "Send TASK_1 to handler.");  
  85.             // 开始任务1（在workHandler的消息队列中获取一个Message对象，避免重复构造）  
  86.             Message msg1 = workHandler.obtainMessage(TASK_1);  
  87.             msg1.obj = "This is task1";  
  88.             workHandler.sendMessage(msg1);  
  89.               
  90.             Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
  91.                 "Send TASK_2 to handler.");           
  92.             // 开启任务2（和上面类似）  
  93.             Message msg2 = Message.obtain();  
  94.             msg2.arg1 = 10;  
  95.             msg2.arg2 = 20;  
  96.             msg2.what = TASK_2;  
  97.             workHandler.sendMessage(msg2);  
  98.   
  99.             Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +  
  100.                 "Send TASK_END to handler.");  
  101.             // 结束任务（空消息体，延时2s投递）  
  102.             workHandler.sendEmptyMessageDelayed(TASK_END, 2000);  
  103.         }  
  104.     }  
  105. }  

运行结果：


方式2

package com.example.androidtest;import android.app.Activity;import android.os.Bundle;import android.os.Handler;import android.os.HandlerThread;import android.os.Looper;import android.os.Message;import android.util.Log;/** * 将消息队列绑定到子线程上，主线程只管通过Handler * 往子线程的消息队列中投递消息即可。 */public class HandlerTest5Activity extends Activity { private final static String TAG = "HandlerTest3Activity";    private static final int TASK_BEGIN = 1; private static final int TASK1 = 2; private static final int TASK2 = 3; private static final int TASK_END = 4;  private MyHandler mHandler = null;  class MyHandler extends Handler {  public MyHandler(Looper looper) {   super(looper);  }  @Override  public void handleMessage(Message msg) {   super.handleMessage(msg);   switch (msg.what) {   case TASK_BEGIN:    Log.i(TAG, "[H_TID:" + Thread.currentThread().getId()      + "] Get TASK_BEGIN");    break;   case TASK1:    Log.i(TAG, "[H_TID:" + Thread.currentThread().getId()      + "] Get TASK1");    break;   case TASK2:    Log.i(TAG, "[H_TID:" + Thread.currentThread().getId()      + "] Get TASK2");    break;   case TASK_END:    Log.i(TAG, "[H_TID:" + Thread.currentThread().getId()      + "] Get TASK_END");    break;   default:    break;   }  } }  @Override protected void onCreate(Bundle savedInstanceState) {  super.onCreate(savedInstanceState);  setContentView(R.layout.activity_handler3);  Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" + "this is main thread");  // Android的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper。// 事实上Android提供了一个封装好的带有looper的线程类，即为HandlerThread// 生成一个HandlerThread对象，该类实现了使用Looper来处理消息队列的功能.    HandlerThread mylHandlerThread = new HandlerThread("my looper thread");  //开启mylHandlerThread，在使用handlerThread.getLooper()之前必须先调用start方法，否则取出的是空   mylHandlerThread.start();  //将handler绑定在mylHandlerThread的Looper上，即这个handler是运行在handlerThread线程中。   Looper looper = mylHandlerThread.getLooper();  mHandler = new MyHandler(looper);  // 启动任务（消息只有标识，立即投递）  mHandler.sendEmptyMessage(TASK_BEGIN);  Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" + "Send TASK_START to handler.");      // 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）  Message msg1 = mHandler.obtainMessage(TASK1);  msg1.obj = "this is task1";  mHandler.sendMessage(msg1);  Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" + "Send TASK_1 to handler.");      // 开启任务2（和上面类似）  Message msg2 = Message.obtain();  msg2.arg1 = 10;  msg2.arg2 = 20;  msg2.what = TASK2;  mHandler.sendMessage(msg2);  Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" + "Send TASK_2 to handler.");  // 结束任务（空消息体，延时2s投递）  mHandler.sendEmptyMessageDelayed(TASK_END, 2000);  Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" + "Send TASK_END to handler."); } @Override protected void onDestroy() {  super.onDestroy(); } }


e、主/子线程均有一个消息队列，然后相互传递消息（这种方式是最灵活的，双向传递，也不复杂）

  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.Looper;  
  7. import android.os.Message;  
  8. import android.util.Log;  
  9.   
  10. public class MainActivity extends Activity {  
  11.     private final static String TAG = "HandlerTest";  
  12.       
  13.     private final static int TASK_BEGIN     = 1;  
  14.     private final static int TASK_1     = 2;  
  15.     private final static int TASK_2     = 3;  
  16.     private final static int TASK_END       = 4;  
  17.       
  18.     private final static int TASK_BEGIN_OVER    = 11;  
  19.     private final static int TASK_1_OVER    = 12;  
  20.     private final static int TASK_2_OVER    = 13;  
  21.     private final static int TASK_END_OVER  = 14;  
  22.       
  23.     private Handler workHandler = null;  
  24.       
  25.     /** Called when the activity is first created. */  
  26.     @Override  
  27.     public void onCreate(Bundle savedInstanceState) {  
  28.         super.onCreate(savedInstanceState);  
  29.         setContentView(R.layout.main);  
  30.   
  31.         Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +  
  32.                 "This is in main thread.");  
  33.           
  34.         LooperThread testThread = new LooperThread();  
  35.         testThread.start();  
  36.           
  37.         // 注意，这里需要等待一下，防止出现空指针异常  
  38.         while (null == workHandler) {  
  39.         }  
  40.           
  41.         testThread.sendMessageTodoYourWork();  
  42.     }  
  43.     
  44.     Handler mainHandler = new Handler () {  
  45.         // 在每个case之后，不能做耗时的操作  
  46.         @Override  
  47.         public void handleMessage(Message msg) {  
  48.             switch (msg.what) {  
  49.             case TASK_BEGIN_OVER:  
  50.                 Log.i(TAG, "[MH_TID:" +  
  51.                     Thread.currentThread().getId() + "] TASK_BEGIN_OVER");  
  52.                 break;  
  53.                   
  54.             case TASK_1_OVER:  
  55.                 Log.i(TAG, "[MH_TID:" +  
  56.                     Thread.currentThread().getId() + "] TASK_1_OVER");  
  57.                 break;  
  58.                   
  59.             case TASK_2_OVER:  
  60.                 Log.i(TAG, "[MH_TID:" +  
  61.                     Thread.currentThread().getId() + "] TASK_2_OVER");  
  62.                 break;  
  63.                   
  64.             case TASK_END_OVER:  
  65.                 Log.i(TAG, "[MH_TID:" +  
  66.                     Thread.currentThread().getId() + "] TASK_END_OVER");  
  67.                 finish();  
  68.                 break;  
  69.             }  
  70.             super.handleMessage(msg);  
  71.         }  
  72.     };  
  73.       
  74.     class LooperThread extends Thread {  
  75.         @Override  
  76.         public void run() {  
  77.             Looper.prepare();  
  78.               
  79.             workHandler = new Handler() {  
  80.                 // 现在在每个case之后，你可以做任何耗时的操作了  
  81.                 @Override  
  82.                 public void handleMessage(Message msg) {  
  83.                     switch (msg.what) {  
  84.                     case TASK_BEGIN:  
  85.                         Log.i(TAG, "[ZH_TID:" +  
  86.                            Thread.currentThread().getId() + "] Get TASK_BEGIN");  
  87.                         // 做完之后报告信息给主线程  
  88.                         mainHandler.sendEmptyMessage(TASK_BEGIN_OVER);  
  89.                         break;  
  90.                           
  91.                     case TASK_1:  
  92.                         Log.i(TAG, "[ZH_TID:" +  
  93.                            Thread.currentThread().getId() + "] Get TASK_1");  
  94.                         // 做完之后报告信息给主线程  
  95.                         mainHandler.sendEmptyMessage(TASK_1_OVER);  
  96.                         break;  
  97.                           
  98.                     case TASK_2:  
  99.                         Log.i(TAG, "[ZH_TID:" +  
  100.                            Thread.currentThread().getId() + "] Get TASK_2");  
  101.                         // 做完之后报告信息给主线程  
  102.                         mainHandler.sendEmptyMessage(TASK_2_OVER);  
  103.                         break;  
  104.                           
  105.                     case TASK_END:  
  106.                         Log.i(TAG, "[ZH_TID:" +  
  107.                            Thread.currentThread().getId() + "] Get TASK_END");  
  108.                         Looper.myLooper().quit();  
  109.                         // 做完之后报告信息给主线程  
  110.                         mainHandler.sendEmptyMessage(TASK_END_OVER);  
  111.                         Looper.myLooper().quit();  
  112.                         break;  
  113.                     }  
  114.                     super.handleMessage(msg);  
  115.                 }  
  116.             };  
  117.               
  118.             Looper.loop();  
  119.         }  
  120.           
  121.         public void sendMessageTodoYourWork() {  
  122.             Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +  
  123.                 "Send TASK_START to handler.");  
  124.             // 启动任务（消息只有标识，立即投递）  
  125.             workHandler.sendEmptyMessage(TASK_BEGIN);  
  126.   
  127.             Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +  
  128.                 "Send TASK_1 to handler.");  
  129.             // 开始任务1（在workHandler的消息队列中获取一个Message对象，避免重复构造）  
  130.             Message msg1 = workHandler.obtainMessage(TASK_1);  
  131.             msg1.obj = "This is task1";  
  132.             workHandler.sendMessage(msg1);  
  133.               
  134.             Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +  
  135.                 "Send TASK_2 to handler.");           
  136.             // 开启任务2（和上面类似）  
  137.             Message msg2 = Message.obtain();  
  138.             msg2.arg1 = 10;  
  139.             msg2.arg2 = 20;  
  140.             msg2.what = TASK_2;  
  141.             workHandler.sendMessage(msg2);  
  142.   
  143.             Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +  
  144.                 "Send TASK_END to handler.");  
  145.             // 结束任务（空消息体，延时2s投递）  
  146.             workHandler.sendEmptyMessageDelayed(TASK_END, 2000);  
  147.         }  
  148.     }  
  149. }  

运行结果：

 

小结：Handler在Android中是很常用的，或是用来更新UI，或是派发任务给子线程去执行，也可以用来产生超时效果，比如用sendMessageDelayed(TASK_TIMEOUT, OUT_TIME)方法。


0 0
贵州卫计委网络直报 贵州卫计委网络直报
原创粉丝点击
热门IT博客
思科网络技术学校pdf思科网络技术学校pdf
python 分布式 webpython 分布式 web
wampserver软件
radius协议端口号
银行小键盘考试软件
java中compare函数
爱知日语培训学校
ps软件怎么安装
鼠标宏设置软件
淘宝卖家级别
广州电脑编程培训班
node全栈开发实战
淘宝店铺怎样宝贝分类
网络商品交易监测系统
数据库的二级映像
mac 连接linux服务器
朝鲜核技术 知乎
苏州朗动网络怎么样
数据库的两级映像包括
什么是ai设计软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 德清旅游景点 德清公共资源交易中心 德清事业单位招聘 德清如林商务宾馆 德清莫干山酒店 德清招聘信息 杭州德清房价 德清公交车时刻表查询 德清特产有哪些 浙江德清旅游 德清有什么好玩的地方 德清武康人才网招聘 德清旅游攻略 德清人才市场 德清哪个楼盘好 德清民宿推荐 德清新开楼盘 德清到莫干山 德清世外桃源农庄 德清莫干山旅游攻略 德清休闲农庄 德清皮肤病研究所 德清去莫干山 德清莫干山度假村 德清楼盘价格 德清哪里好玩 德清莫干山门票价格 德清职业中专 湖州德清房价 德清旅游必去的景点 德清莫干山镇 德清月潭温泉度假村 浙江德清房价 德清事业单位 德清莫干山皇后饭店 德清莫干山鸟巢度假别墅 德清莫干山竹里馆 德清星级酒店 德清火车站到莫干山 德清房产信息 德清下渚湖风景区

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里