程序博客网 > 全国居民小区数据库

android中handler案例

来源：互联网 发布：全国居民小区数据库 编辑：程序博客网 时间：2024/04/29 01:12

前言
　　学习android一段时间了，为了进一步了解android的应用是如何设计开发的，决定详细研究几个开源的android应用。从一些开源应用中吸收点东西，一边进行量的积累，一边探索android的学习研究方向。这里我首先选择了jwood的 Standup Timer 项目。本文将把研究的内容笔记整理，建立一个索引列表。
关键词
　　Android.os.Handler涉及较多的知识点，我把一些关键词列举在下面，将主要介绍Handler：
android.os.Handler 、 android.os.Handler.Callback 
Looper、 
Threadle、Runnable 
Message、Message queue 
android.os.Handler
　　Handler在android里负责发送和处理消息。它的主要用途有：
　　1）按计划发送消息或执行某个Runnanble(使用POST方法)；
　　2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）
　　 默认情况下，Handler接受的是当前线程下的消息循环实例（使用Handler(Looper looper)、Handler(Looper looper, Handler.Callback callback)可以指定线程），同时一个消息队列可以被当前线程中的多个对象进行分发、处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个Handler来处理）。在实例化Handler的时候，Looper可以是任意线程的，只要有Handler的指针，任何线程也都可以sendMessage。Handler对于Message的处理不是并发的。一个Looper 只有处理完一条Message才会读取下一条，所以消息的处理是阻塞形式的（handleMessage()方法里不应该有耗时操作，可以将耗时操作放在其他线程执行，操作完后发送Message（通过sendMessges方法）,然后由handleMessage()更新UI）。
倒计时程序
　　利用Timer 编写一个倒计时程序，程序使用Timer和TimerTask来完成倒计时，同时使用sendMessages方法发送消息，然后在HanleMessage里更新UI。
Activity布局：
layout
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:orientation="vertical"
  4.     android:layout_width="fill_parent"
  5.     android:layout_height="fill_parent"
  6.     >
  7. <TextView  
  8.     android:layout_width="fill_parent" 
  9.     android:layout_height="wrap_content" 
  10.     android:layout_gravity="center"
  11.     android:id="@+id/txt"
  12.     />
  13. <Button
  14.     android:id="@+id/btnStartTime"
  15.     android:text="开始计时"
  16.     android:layout_width="80dip"
  17.     android:layout_height="wrap_content" 

  19.     ></Button>
  20. <Button
  21.      android:id="@+id/btnStopTime"
  22.      android:text="停止计时"
  23.      android:layout_width="80dip"
  24.     android:layout_height="wrap_content"
  25.   />
  26.   
  27. <SeekBar android:id="@+id/SeekBar01" android:layout_width="match_parent" android:layout_height="wrap_content"></SeekBar>
  28. </LinearLayout>
复制代码
这里使用TextView 来显示倒计时的时间变化，两个按钮用于控制时间的开始和停止。SeekBar主要是用于查看线程是否被阻塞（阻塞时无法拖动）。
  1. onCreate 
  2. @Override
  3.     public void onCreate(Bundle savedInstanceState) {
  4.         super.onCreate(savedInstanceState);
  5.         setContentView(R.layout.main);
  6.         txt = (TextView) findViewById(R.id.txt);
  7.         btnStart = (Button) findViewById(R.id.btnStartTime);
  8.         btnStop = (Button) findViewById(R.id.btnStopTime);
  9.         Log.d("ThreadId", "onCread:"
  10.                 + String.valueOf(Thread.currentThread().getId()));
  11.         myHandler = new Handler(this);

  13.         btnStart.setOnClickListener(this);
  14.         btnStop.setOnClickListener(this);

  16.     }
复制代码
在onCreate方法中初始化元素个元素，myHandler = new Handler(this); 调用的是  Handler(Handler.Callback callback)构造函数，在回调方法callback中对发送来的消息进行处理（这样我们就不必使用内部类的写法来 重写HandleMessage()方法了），因此Activity必须实现 android.os.Handler.Callback 接口。我们还在将onCreate 方法的ThreadId 记录在了Log中用以和消息发送、处理时所作的线程进行比较。
发送消息
  1.     @Override
  2.     public void onClick(View v) {
  3.         switch (v.getId()) {
  4.         case R.id.btnStartTime:
  5.             startTimer();
  6.             break;
  7.         case R.id.btnStopTime:
  8.             timer.cancel();

  10.             break;
  11.         }

  13.     }

  15.     private synchronized void startTimer() {

  17.         timer = new Timer();
  18.         // TimerTask updateTimerValuesTask = new TimerTask() {
  19.         // @Override
  20.         // public void run() {
  21.         // updateTimerValues();
  22.         // }
  23.         //
  24.         // };
  25.         //自定义的CallBack模式。Task继承自TimerTask
  26.         Task updateTimerValuesTask = new Task(this);

  28.         timer.schedule(updateTimerValuesTask, 1000, 1000);
  29.     }

  31.     //执行耗时的倒计时任务。
  32.     private void updateTimerValues() {
  33.         total--;

  35.         Log.d("ThreadId", "send:"
  36.                 + String.valueOf(Thread.currentThread().getId()));
  37.         
  38.         Message msg=new Message();
  39.         Bundle date = new Bundle();// 存放数据
  40.         date.putInt("time", total);
  41.         msg.setData(date);
  42.         msg.what=0;
  43.         myHandler.sendMessage(msg);

  45.         //另一种写法
  46. //        Message msg=myHandler.obtainMessage();
  47. //        Bundle date = new Bundle();// 存放数据
  48. //        date.putInt("time", total);
  49. //        msg.setData(date);
  50. //        msg.what=0;
  51. //        msg.sendToTarget();
  52.         
  53.     }

  55.     @Override
  56.     public void TaskRun() {
  57.         updateTimerValues();

  59.     }
复制代码
实现Button按钮的事件处理以此进入倒计时操作。这里使用的Timer 来执行定时操作（其实我们完全可以另起一个线程）。Task类继承了TimerTask类,里面增加了一个任务处理接口来实现回调模式，应此Activity需要实现该回调的接口 ITaskCallBack（这样做是因为我比较不喜欢内部类的编写方法）。
ICallBack接口和Task类
  1. public interface ITaskCallBack {

  3.     void TaskRun();
  4. }



  8. public class Task extends TimerTask {

  10.     private ITaskCallBack iTask;
  11.     
  12.     public Task(ITaskCallBack iTaskCallBack)
  13.     {
  14.         super();
  15.         iTask=iTaskCallBack;
  16.     }
  17.     
  18.     public void setCallBack(ITaskCallBack iTaskCallBack)
  19.     {
  20.         iTask=iTaskCallBack;
  21.     }
  22.     @Override
  23.     public void run() {
  24.         // TODO Auto-generated method stub
  25.         iTask.TaskRun();
  26.     }

  28. }
复制代码
这是Java的回调函数的一般写法。
实现CallBack
  1.     /**
  2.      * 实现消息处理
  3.      */
  4.     @Override
  5.     public boolean handleMessage(Message msg) {
  6.     
  7.         switch(msg.what)
  8.         {
  9.         case 0:
  10.             Bundle date=msg.getData();
  11.             txt.setText(String.valueOf(date.getInt("time")));
  12.             
  13.             Log.d("ThreadId", "HandlerMessage:"
  14.                     + String.valueOf(Thread.currentThread().getId()));
  15.             Log.d("ThreadId", "msgDate:"
  16.                     + String.valueOf(date.getInt("time")));
  17.             break;

  19.         }
  20.         return false;
  21.     }
复制代码
　　可以看到 实现 android.os.Handler.Callback 接口，其实就是对handleMessage（）方法进行重写（和内部类的一个区别是，内部类的返回值是Void）。
运行结果

　　可以看到在onCreate 方法中线程的ID是1（UI线程） 这与 HandlerMessage 进行消息处理时是所作的线程ID是一样的，而消息发送的线程ID则为8非UI线程。
使用Threadle进行实现
Activity类
  1. public class ThreadHandlerrActivity extends Activity implements Callback,
  2.         OnClickListener {

  4.     private TextView txt;
  5.     private Button btnStart, btnStop;
  6.     private Handler myHandler;
  7.     private TimerThread timerThread;
  8.     private int Total=30;


  11.     /** Called when the activity is first created. */
  12.     @Override
  13.     public void onCreate(Bundle savedInstanceState) {
  14.         super.onCreate(savedInstanceState);
  15.         setContentView(R.layout.main);
  16.         txt = (TextView) findViewById(R.id.txt);
  17.         btnStart = (Button) findViewById(R.id.btnStartTime);
  18.         btnStop = (Button) findViewById(R.id.btnStopTime);
  19.         Log.d("ThreadId", "onCread:"
  20.                 + String.valueOf(Thread.currentThread().getId()));
  21.         myHandler = new Handler(this);
  22.         
  23.     
  24.         btnStart.setOnClickListener(this);
  25.         btnStop.setOnClickListener(this);

  27.     }

  29.     /**
  30.      * 实现消息处理
  31.      */
  32.     @Override
  33.     public boolean handleMessage(Message msg) {
  34.     
  35.         switch(msg.what)
  36.         {
  37.         case 0:
  38.             Bundle date=msg.getData();
  39.             txt.setText(String.valueOf(date.getInt("time")));
  40.             
  41.             Log.d("ThreadId", "HandlerMessage:"
  42.                     + String.valueOf(Thread.currentThread().getId()));
  43.             Log.d("ThreadId", "msgDate:"
  44.                     + String.valueOf(date.getInt("time")));
  45.             break;

  47.         }
  48.         return false;
  49.     }

  51.     @Override
  52.     public void onClick(View v) {
  53.         switch (v.getId()) {
  54.         case R.id.btnStartTime:
  55.             //自定义的线程
  56.         timerThread=new TimerThread(myHandler,60);
  57.             timerThread.start();
  58.             
  59.             break;
  60.         case R.id.btnStopTime:
  61.             timerThread.stop();
  62.             //timerThread.destroy();
  63.             break;
  64.         }

  66.     }

  68.     
  69.         
  70.     
  71. }
复制代码
自定义的线程类
  1. **
  2. * 自定义的线程类，通过传入的Handler,和Total 定期执行耗时操作
  3. * @author linzijun
  4. *
  5. */
  6. public class TimerThread extends Thread  {

  8.     public int Total=60;
  9.     public Handler handler;
  10.     /**
  11.      * 初始化构造函数
  12.      * @param mhandler handler 用于发送消息
  13.      * @param total 总周期
  14.      */
  15.     public TimerThread(Handler mhandler,int total)
  16.     {
  17.         super();
  18.         handler=mhandler;
  19.         Total=total;
  20.     }
  21.     @Override
  22.     public void run() {
  23.         
  24.         while(true)
  25.         {
  26.             Total--;
  27.             if(Total<0)
  28.                 break;
  29.             try {
  30.                 Thread.sleep(1000);
  31.             } catch (InterruptedException e) {
  32.                 // TODO Auto-generated catch block
  33.                 e.printStackTrace();
  34.             }
  35.             Message msg=new Message();
  36.             Bundle date = new Bundle();// 存放数据
  37.             date.putInt("time", Total);
  38.             msg.setData(date);
  39.             msg.what=0;
  40.             Log.d("ThreadId", "Thread:"
  41.                     + String.valueOf(Thread.currentThread().getId()));
  42.             handler.sendMessage(msg);
  43.             
  44.             
  45.         }
  46.         
  47.         super.run();
  48.     }

  50.     
  51.     
  52. }
复制代码
这里继承了Thread类，也可以直接实现 Runnable接口。
关于POST
　　Post的各种方法是把一个Runnable发送给消息队列，它将在到达时进行处理。
POST
  1. public class PostHandler extends Activity implements OnClickListener, Runnable {

  3.     private TextView txt;
  4.     private Button btnStart, btnStop;
  5.     private Handler myHandler;
  6.     private Timer timer;
  7.     private int total = 60;

  9.     
  10.     @Override
  11.     protected void onCreate(Bundle savedInstanceState) {
  12.         // TODO Auto-generated method stub
  13.         super.onCreate(savedInstanceState);

  15.         setContentView(R.layout.main);
  16.         txt = (TextView) findViewById(R.id.txt);
  17.         btnStart = (Button) findViewById(R.id.btnStartTime);
  18.         btnStop = (Button) findViewById(R.id.btnStopTime);
  19.         Log.d("ThreadId", "onCread:"
  20.                 + String.valueOf(Thread.currentThread().getId()));
  21.         myHandler = new Handler()
  22.         {

  24.             @Override
  25.             public void handleMessage(Message msg) {
  26.                 switch(msg.what)
  27.                 {
  28.                 case 0:
  29.                     Bundle date=msg.getData();
  30.                     txt.setText(String.valueOf(date.getInt("time")));
  31.                     
  32.                     Log.d("ThreadId", "HandlerMessage:"
  33.                             + String.valueOf(Thread.currentThread().getId()));
  34.                     Log.d("ThreadId", "msgDate:"
  35.                             + String.valueOf(date.getInt("time")));
  36.                     break;

  38.                 }
  39.     
  40.             }
  41.             
  42.         };

  44.         btnStart.setOnClickListener(this);
  45.         btnStop.setOnClickListener(this);
  46.     }

  48.     @Override
  49.     public void onClick(View v) {
  50.         switch (v.getId()) {
  51.         case R.id.btnStartTime:
  52.             //myHandler.post(this);
  53.             myHandler.postDelayed(this, 1000);
  54.             break;
  55.         case R.id.btnStopTime:
  56.             
  57.             break;
  58.         }
  59.         
  60.     }

  62.     @Override
  63.     public void run() {
  64.         while(true)
  65.         {
  66.             total--;
  67.             if(total<0)
  68.                 break;
  69.             try {
  70.                 Thread.sleep(1000);
  71.             } catch (InterruptedException e) {
  72.                 // TODO Auto-generated catch block
  73.                 e.printStackTrace();
  74.             }
  75.             Message msg=new Message();
  76.             Bundle date = new Bundle();// 存放数据
  77.             date.putInt("time", total);
  78.             msg.setData(date);
  79.             msg.what=0;
  80.             Log.d("ThreadId", "POST:"
  81.                     + String.valueOf(Thread.currentThread().getId()));
  82.             myHandler.sendMessage(msg);
  83.             Log.d("ThreadId", "Thread:"
  84.                     + String.valueOf(Thread.currentThread().getId()));

  86.         }
  87.         
  88.     }

  90. }
复制代码
使用POST的方式 是将Runnable 一起发送给处理的线程（这里为UI），如果Runnable的操作比较耗时的话那线程将进入阻塞状态。可以看到先运行 Runnable的Run方法 然后在进入 HandleMessage（） 。我还尝试了另一种写法，将TimerThreadPOST过去，运行结果是一样的。
代码
  1. package zijunlin.me;

  3. import java.util.Timer;

  5. import android.app.Activity;
  6. import android.os.Bundle;
  7. import android.os.Handler;
  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.TextView;

  15. public class PostHandler extends Activity implements OnClickListener, Runnable {

  17.     private TextView txt;
  18.     private Button btnStart, btnStop;
  19.     private Handler myHandler;
  20.     private Timer timer;
  21.     private int total = 60;
  22.     private TimerThread timerThread;
  23.     
  24.     @Override
  25.     protected void onCreate(Bundle savedInstanceState) {
  26.         // TODO Auto-generated method stub
  27.         super.onCreate(savedInstanceState);

  29.         setContentView(R.layout.main);
  30.         txt = (TextView) findViewById(R.id.txt);
  31.         btnStart = (Button) findViewById(R.id.btnStartTime);
  32.         btnStop = (Button) findViewById(R.id.btnStopTime);
  33.         Log.d("ThreadId", "onCread:"
  34.                 + String.valueOf(Thread.currentThread().getId()));
  35.         myHandler = new Handler()
  36.         {

  38.             @Override
  39.             public void handleMessage(Message msg) {
  40.                 switch(msg.what)
  41.                 {
  42.                 case 0:
  43.                     Bundle date=msg.getData();
  44.                     txt.setText(String.valueOf(date.getInt("time")));
  45.                     
  46.                     Log.d("ThreadId", "HandlerMessage:"
  47.                             + String.valueOf(Thread.currentThread().getId()));
  48.                     Log.d("ThreadId", "msgDate:"
  49.                             + String.valueOf(date.getInt("time")));
  50.                     break;

  52.                 }
  53.     
  54.             }
  55.             
  56.         };

  58.         btnStart.setOnClickListener(this);
  59.         btnStop.setOnClickListener(this);
  60.     }

  62.     @Override
  63.     public void onClick(View v) {
  64.         switch (v.getId()) {
  65.         case R.id.btnStartTime:
  66.             //myHandler.post(this);
  67.             //myHandler.postDelayed(this, 1000);
  68.             timerThread=new TimerThread(myHandler,60);
  69.             
  70.             myHandler.post(timerThread);
  71.             break;
  72.         case R.id.btnStopTime:
  73.             
  74.             break;
  75.         }
  76.         
  77.     }

  79.     @Override
  80.     public void run() {
  81.         while(true)
  82.         {
  83.             total--;
  84.             if(total<0)
  85.                 break;
  86.             try {
  87.                 Thread.sleep(1000);
  88.             } catch (InterruptedException e) {
  89.                 // TODO Auto-generated catch block
  90.                 e.printStackTrace();
  91.             }
  92.             Message msg=new Message();
  93.             Bundle date = new Bundle();// 存放数据
  94.             date.putInt("time", total);
  95.             msg.setData(date);
  96.             msg.what=0;
  97.             Log.d("ThreadId", "POST:"
  98.                     + String.valueOf(Thread.currentThread().getId()));
  99.             myHandler.sendMessage(msg);
  100.             Log.d("ThreadId", "Thread:"
  101.                     + String.valueOf(Thread.currentThread().getId()));

  103.         }
  104.         
  105.     }

  107. }
复制代码

可以说POST的各种方法主要是用于 “按计划发送消息或执行某个Runnanble(使用POST方法)”。


文章原文http://www.eoeandroid.com/thread-116154-1-1.html

全国居民小区数据库 全国居民小区数据库
原创粉丝点击
热门IT博客
sql计算总和sql计算总和
淘宝店铺信誉度怎么看淘宝店铺信誉度怎么看
软件怎么组织投标
村上春树经典语录知乎
sqlserver触发器实例
淘宝远程租用电脑
数据库管理员培训学费
比价系统源码
扫矿老僧软件使用视频
p2p播放软件
购物网络平台有哪些
淘宝卖家辅助软件
node forever log
淘宝退货运费差价
汉语彝文在线翻译软件
黑白网络网址
soc管理平台 知乎
originlab mac版
淘宝卖家新手教程
《算法》6本
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 学挖掘机要多久 开挖机 挖机学校 挖掘机难学吗 学挖掘机技术哪家强 学开挖机要多久 山东蓝翔挖掘机学校 挖掘机技术学习 学挖掘机怎么样 挖掘机前景如何 挖掘机好学吗 挖机培训学校 学挖机有前途吗 挖土机 挖掘机技校 挖掘机学校培训 挖掘机学校 学挖掘机多少学费 学挖掘机有前途吗 中国挖掘机网 挖机图片 挖士机 挖机照片 挖机价格大全 挖机型号大全 挖掘机价格型号图片 挖土机价格 挖掘机价格表 挖机图 大挖机图片 挖机市场 挖机多少钱 挖掘机型号规格 挖机视屏 waji 挖掘机大全 大挖机 挖土机图片 挖机价格 挖挖机 挖掘机视屏

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