使用Handler管理线程

520阅读　0评论2013-07-15　黑曼巴snake
分类：Android平台

步骤：

1. 申请一个Handler对象

Handler handler = new Handler();

2. 创建一个线程

{继承Thread类或者实现Runnable这个接口}

使用Runnable创建一个内部匿名类对象updateThread（要复写run方法）

3. 使用handler的post方法将线程加入到线程队列中

handler.post(updateThread);

4. 使用handler的removeCallbacks方法移出updateThread线程

注意：如果线程从线程队列中出来被执行后，则队列中就不在有线程

因此如果线程在被执行后没有方法将其再次加入到队列中，则无需使用removeCallbacks

线程走出线程队列有两种情况：

一种是被执行，此时要执行run方法

一种是使用removeCallbacks方法，此时线程不被执行，因此不调用run

5. 使用handler的postDelayed方法延时将线程加入到队列中

handler.postDelayed(updateThread,3000)

下面给出一个简单的代码：

点击(此处)折叠或打开

  1. package my.handler;
  2.  
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.os.Handler;
  6. import android.view.View;
  7. import android.view.View.OnClickListener;
  8. import android.widget.Button;
  9.  
  10. public class HandleruseActivity extends Activity {
  11.     /** Called when the activity is first created. */
  12.     //声明两个控件变量
  13.     private Button startButton = null;
  14.     private Button endButton = null;
  15.     @Override
  16.     public void onCreate(Bundle savedInstanceState) {
  17.         super.onCreate(savedInstanceState);
  18.         setContentView(R.layout.main);
  19.          
  20.         //获取控件对象
  21.         startButton = (Button)findViewById(R.id.startButton);
  22.         endButton = (Button)findViewById(R.id.endButton);
  23.          
  24. // 设置监听器
  25.         startButton.setOnClickListener(new startListener());
  26.         endButton.setOnClickListener(new endListener());
  27.     }
  28.     class startListener implements OnClickListener{
  29.  
  30.         @Override
  31.         public void onClick(View v) {
  32.             // TODO Auto-generated method stub
  33. // 将线程updateThread加入到线程队列中
  34.             handler.post(updateThread);
  35.         }
  36.     }
  37.     class endListener implements OnClickListener{
  38.  
  39.         @Override
  40.         public void onClick(View v) {
  41.             // TODO Auto-generated method stub
  42. // 将线程updateThread移出线程队列
  43.             handler.removeCallbacks(updateThread);
  44.         }
  45.          
  46.     }
  47.      
  48. // 申请handler对象
  49.     Handler handler = new Handler();
  50.  
  51. // 创建一个线程,线程被调用时一定是调用其run函数
  52.   /* Runnable updateThread = new Runnable(){
  53.         public void run(){
  54.             System.out.println("UpdateThread");
  55. // 延迟三秒之后将线程updateData加入到线程队列当中
  56.             handler.postDelayed(updateThread, 3000);
  57.         }
  58.     };*/
  59. // 继承Runnable 或者继承 Thread
  60.     Thread updateThread = new Thread(){
  61.         public void run(){
  62.             System.out.println("UpdateThread Thread");
  63.          // 延迟三秒之后将线程updateData加入到线程队列当中
  64.             handler.postDelayed(updateThread, 3000);
  65.         }
  66.     };
  67. }


?

点击(此处)折叠或打开

  1. package progressBar.handler;
  2.  
  3. import android.app.Activity;
  4. import android.os.Bundle;
  5. import android.os.Handler;
  6. import android.os.Message;
  7. import android.view.View;
  8. import android.view.View.OnClickListener;
  9. import android.widget.Button;
  10. import android.widget.ProgressBar;
  11.  
  12. public class ProgressBarHandlerActivity extends Activity {
  13.     /** Called when the activity is first created. */
  14.     private Button startButton = null;
  15.     private ProgressBar bar = null;
  16.     int i=0;
  17.     @Override
  18.     public void onCreate(Bundle savedInstanceState) {
  19.         super.onCreate(savedInstanceState);
  20.         setContentView(R.layout.main);
  21.         startButton = (Button)findViewById(R.id.startButton);
  22.         bar = (ProgressBar)findViewById(R.id.bar);
  23.         startButton.setOnClickListener(new startListener());
  24.     }
  25.     class startListener implements OnClickListener{
  26.  
  27.         @Override
  28.         public void onClick(View v) {
  29.             // TODO Auto-generated method stub
  30.             bar.setVisibility(View.VISIBLE);
  31.             handler.post(updateBar);
  32.         }
  33.     }
  34.      
  35. // handler内部实现一个匿名内部类，重载消息处理函数
  36. // 当消息从队列中被取出的时候调用handleMessage函数处理消息
  37. // 这样做的好处是使用参数arg1效率比较高
  38.     Handler handler = new Handler(){
  39.         public void handleMessage(Message msg){
  40.             bar.setProgress(msg.arg1);
  41.             handler.post(updateBar);
  42.         }
  43.     };
  44.      
  45.     Thread updateBar = new Thread(){
  46.         public void run(){
  47.             System.out.println("Begin Thread!");
  48.             i=i+1;
  49.             Message msg = handler.obtainMessage();
  50.             msg.arg1=i;
  51.             try{
  52.                 Thread.sleep(1000);
  53.             }catch(InterruptedException e){
  54.                 e.printStackTrace();
  55.             }
  56. // 发送消息，将消息加入到消息队列中
  57.             handler.sendMessage(msg);
  58.         if(i==100)
  59.         {
  60.             handler.removeCallbacks(updateBar);
  61.         }
  62.         }
  63.     };
  64. }

注意：用post方法将线程对象放到队列里面执行，并没有开启一个新的线程，而是直接调用线程

对象的run方法，因此并没有实现线程的异步。

解决的办法是先生成一个HandlerThread对象，启动它（start）

使用handlerThread对象的getLooper方法取得其looper对象，注意在此之前必须要start，否则这个

looper是空的

并将looper对象作为参数传递给handler对象，使得这个handler对象绑定到这个Looper所在线程上面

此时需要重写handler类的构造函数，将looper对象传给父类

Looper：类，提供一种循环的从队列当中取得消息的功能，不要自己创建

这样，这个handler就可以循环的从Message消息队列中不断取消息。

下面使用这个办法的代码：

点击(此处)折叠或打开

  1. package handler.extr;
  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.  
  10. public class HandlerExtrActivity extends Activity {
  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. // 生成一个HandlerThread对象，此对象实现了使用Looper来处理消息队列的功能
  17.         HandlerThread handlerThread = new HandlerThread("handler-thread");
  18. // 启动线程
  19.         handlerThread.start();
  20.         MyHandler myHandler = new MyHandler(handlerThread.getLooper());
  21.         Message msg0 = myHandler.obtainMessage();
  22.         Bundle b = new Bundle();
  23.         b.putInt("age", 25);
  24.         b.putString("name","xiaocheng");
  25.         msg0.setData(b);
  26.         msg0.arg1=0;
  27. // 将消息发送到目标对象，所谓目标对象就是生成该msg对象的handler对象
  28.         msg0.sendToTarget();
  29.         System.out.println("Activity--->"+Thread.currentThread().getId());
  30.     }
  31. // 要实现消息的处理则需要继承复写handleMessage方法
  32. // 一旦使用继承，则需要重写构造函数传送Looper参数
  33.     class MyHandler extends Handler{
  34.         public MyHandler(){
  35.              
  36.         }
  37.         public MyHandler(Looper looper){
  38.             super(looper);
  39.         }
  40.         @Override
  41.         public void handleMessage(Message msg) {
  42.             // TODO Auto-generated method stub
  43.             int age = msg.getData().getInt("age");
  44.             String name = msg.getData().getString("name");
  45.             System.out.println("handler--->"+Thread.currentThread().getId());
  46.             System.out.println("My name is "+name+", and my age is "+age);
  47.             System.out.println("msg ---- agr1 is "+msg.arg1);
  48.             try{
  49.                 Thread.sleep(1000);
  50.             }catch(InterruptedException e){
  51.                 e.printStackTrace();
  52.             }
  53.             super.handleMessage(msg);
  54.              
  55.         }
  56.          
  57.     }
  58. }


?
转自http://www.cnblogs.com/xiao-cheng/archive/2011/11/05/2237500.htm
上一篇：AsyncTask的用法
下一篇：AchartEngineActivity引擎绘制柱状图、曲线图