程序博客网 > 易建联的雄鹿赛季知乎

handler使用3

来源：互联网 发布：易建联的雄鹿赛季知乎 编辑：程序博客网 时间：2024/06/16 22:42

Android中有关Handler的使用（三）

 

 

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

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

运行结果：

 

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

[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.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博客
网络大学本科算统招吗网络大学本科算统招吗
c语言求m n最大公约数c语言求m n最大公约数
一元云购软件
淘宝客关键词
mac辣椒色是什么色号
琴台故径 知乎
inside mac破解版
网络教育双重学籍
js面向对象编程的看法
公司域名注册流程
sqlserver rowcount
数据防泄漏系统
淘宝店铺可以买吗
淘宝福利店主
ubuntu查看隐藏文件
行业门户网站源码
淘宝怎么登录子账号
阴阳师姑获鸟觉醒数据
淘宝雅诗兰黛官方网
淘宝卖家怎么加入消保
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 你猜呀 你猜啊 我说你猜 你猜我猜不猜 女生说你猜高情商回复 你猜怎么幽默回答 我画你猜题目及配图 你猜的神回复 你猜我猜不猜幽默回答 你猜我猜猜猜猜 你猜我画词语 我画你猜安卓版下载 你猜我猜不猜的神回复 4399我画你猜 我画你猜题目和答案 你猜用英语怎么说 我画你猜题目大全 你猜我猜不猜绕口令 我画你猜成语 别人说你猜神回复 猜谜语 你比我猜词语大全 猹 闰土和猹 猹怎么读 你是闰土我是猹什么梗 猹图片 猹是什么动物 猹的图片 刺猹 闰土刺猹图片 闰土与猹表情包 闰土和猹原文 传说之下猹图片 炭烧乌龙猹作品 瞒天道祖 有猹爱的闰哥 查理普斯为什么叫猹 哈你 你你看 你对 你呀

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