Android中的Handler, Looper, MessageQueue, Thread -- 使用心得

一、几个关键概念

我们开始这部分的内容,首先了解一下各自的职责:

1):Message:消息,其中包含了其中包括了Message的ID,Message的对象以及要处理的数据,有MessageQueue

统一列队,最终由Handler处理。

2):MessageQueue:消息队列,用来存放Handler发来的消息。message并非指实际意义的存放,而是以链表的

方式串联起来。等待looper的抽取。MessageQueue的实例化分为两种情况:主线程创建时,他的实例化过程是

在Looper的私有化构造函数looper()中实例化的。而非主线程创建时,不会主动的创建Looper,需要的时候是

要通过Looper.prepare()来创建。在创建Looper时才创建MessageQueue。


3):Handler:句柄及处理类,handler将需要传递的数据封装成message,通过调用handler对象的obtainMessage

()来实现。然后将消息传递给Looper,通过handler的sendMessage()来实现。继而由Looper将Message放入到

MessageQueue中。当looper对象看到MessageQueue中有消息时,就将广播出去,Handler接收到数据后,调用相应

的handler对象的handMessage()方法对其进行处理。


4):Looper:是MessageQueue的管理者。每一个MessageQueue都不能脱离Looper而存在,Looper对象的创建是通

过prepare函数来实现的。同时每一个Looper对象和一个线程关联。通过调用Looper.myLooper()可以获得当前线程

的Looper对创建一个Looper对象时,会同时创建一个MessageQueue对象。除了主线程有默认的Looper,其他线程

默认是没有MessageQueue对象的,所以,不能接受Message。如需要接受,自己定义 一个Looper对象(通过prepare

函数),这样该线程就有了自己的Looper对象和MessageQueue数据结构了。 Looper从MessageQueue中取出Message

然后,交由Handler的handleMessage进行处理。处理完成后,调用Message.recycle()将其放入Message Pool中。


5):Thread:负责调度整个消息循环。及消息循环的执行场所。


二、线程之间的消息如何进行传递 

1、主线程给自己发送Message 

Java代码   收藏代码
  1. package test.message;   
  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.view.View ;  
  9. import android.widget.Button;  
  10. import android.widget.TextView ;  
  11.   
  12. public class MainActivity extends Activity {   
  13.       
  14.     private Button btnTest;  
  15.     private TextView textView;  
  16.       
  17.     private Handler handler ;  
  18.       
  19.     @Override  
  20.     public void onCreate(Bundle savedInstanceState) {  
  21.         super.onCreate(savedInstanceState);  
  22.         setContentView(R.layout.main);  
  23.           
  24.         btnTest = (Button)this.findViewById(R.id.btn_01);  
  25.         textView = (TextView)this.findViewById(R.id.view_01);  
  26.           
  27.         btnTest.setOnClickListener(new View.OnClickListener() {  
  28.               
  29.             @Override  
  30.             public void onClick(View arg0) {  
  31.                   
  32.                 Looper looper = Looper.getMainLooper(); //主线程的Looper对象  
  33.                 //这里以主线程的Looper对象创建了handler ,  
  34.                 //所以,这个handler 发送的Message会被传递给主线程的MessageQueue。  
  35.                 handler = new MyHandler(looper);  
  36.                 handler .removeMessages(0);  
  37.                 //构建Message对象  
  38.                 //第一个参数:是自己指定的message代号,方便在handler 选择性地接收  
  39.                 //第二三个参数没有什么意义  
  40.                 //第四个参数需要封装的对象  
  41.                 Message msg = handler .obtainMessage(1,1,1,"主线程发消息了");  
  42.                   
  43.                 handler .sendMessage(msg); //发送消息  
  44.                   
  45.             }  
  46.         });  
  47.     }  
  48.       
  49.     class MyHandler extends Handler{  
  50.           
  51.         public MyHandler(Looper looper){  
  52.             super(looper);  
  53.         }  
  54.           
  55.         public void handleMessage(Message msg){  
  56.             super.handleMessage(msg);  
  57.             textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  58.         }  
  59.     }  
  60. }  

2、其他线程给主线程发送Message 

Java代码   收藏代码
  1. package test.message;   
  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.view.View;  
  9. import android.widget.Button;  
  10. import android.widget.TextView;  
  11.   
  12. public class MainActivity extends Activity {   
  13.       
  14.     private Button btnTest;  
  15.     private TextView textView;  
  16.       
  17.     private Handler handler ;  
  18.       
  19.     @Override  
  20.     public void onCreate(Bundle savedInstanceState) {  
  21.         super.onCreate(savedInstanceState);  
  22.         setContentView(R.layout.main);  
  23.           
  24.         btnTest = (Button)this.findViewById(R.id.btn_01);  
  25.         textView = (TextView)this.findViewById(R.id.view_01);  
  26.           
  27.         btnTest.setOnClickListener(new View.OnClickListener() {  
  28.               
  29.             @Override  
  30.             public void onClick(View arg0) {  
  31.                   
  32.                 //可以看出这里启动了一个线程来操作消息的封装和发送的工作  
  33.                 //这样原来主线程的发送就变成了其他线程的发送,简单吧?呵呵  
  34.                 new MyThread().start();      
  35.             }  
  36.         });  
  37.     }  
  38.       
  39.     class MyHandler extends Handler{  
  40.           
  41.         public MyHandler(Looper looper){  
  42.             super(looper);  
  43.         }  
  44.           
  45.         public void handleMessage(Message msg){  
  46.             super.handleMessage(msg);  
  47.             textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  48.         }  
  49.     }  
  50.       
  51.     //加了一个线程类  
  52.     class MyThread extends Thread{  
  53.           
  54.         public void run(){  
  55.             Looper looper = Looper.getMainLooper(); //主线程的Looper对象  
  56.             //这里以主线程的Looper对象创建了handler ,  
  57.             //所以,这个handler 发送的Message会被传递给主线程的MessageQueue。  
  58.             handler = new MyHandler(looper);  
  59.   
  60.             //构建Message对象  
  61.             //第一个参数:是自己指定的message代号,方便在handler 选择性地接收  
  62.             //第二三个参数没有什么意义  
  63.             //第四个参数需要封装的对象  
  64.             Message msg = handler .obtainMessage(1,1,1,"其他线程发消息了");  
  65.               
  66.             handler .sendMessage(msg); //发送消息              
  67.         }  
  68.     }  
  69. }  


3、主线程给其他线程发送Message 

Java代码   收藏代码
  1. package test.message;   
  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.view.View;  
  9. import android.widget.Button;  
  10. import android.widget.TextView;  
  11.   
  12. public class MainActivity extends Activity {   
  13.       
  14.     private Button btnTest;  
  15.     private TextView textView;  
  16.       
  17.     private Handler handler ;  
  18.       
  19.     @Override  
  20.     public void onCreate(Bundle savedInstanceState) {  
  21.         super.onCreate(savedInstanceState);  
  22.         setContentView(R.layout.main);  
  23.           
  24.         btnTest = (Button)this.findViewById(R.id.btn_01);  
  25.         textView = (TextView)this.findViewById(R.id.view_01);  
  26.           
  27.           
  28.         //启动线程  
  29.         new MyThread().start();      
  30.           
  31.         btnTest.setOnClickListener(new View.OnClickListener() {  
  32.               
  33.             @Override  
  34.             public void onClick(View arg0) {  
  35.                 //这里handler 的实例化在线程中  
  36.                 //线程启动的时候就已经实例化了  
  37.                 Message msg = handler .obtainMessage(1,1,1,"主线程发送的消息");  
  38.                 handler .sendMessage(msg);  
  39.             }  
  40.         });  
  41.     }  
  42.       
  43.     class MyHandler extends Handler{  
  44.           
  45.         public MyHandler(Looper looper){  
  46.             super(looper);  
  47.         }  
  48.           
  49.         public void handleMessage(Message msg){  
  50.             super.handleMessage(msg);  
  51.             textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  52.         }  
  53.     }  
  54.       
  55.     class MyThread extends Thread{  
  56.           
  57.         public void run(){  
  58.             Looper.prepare(); //创建该线程的Looper对象,用于接收消息  
  59.               
  60.             //注意了:这里的handler 是定义在主线程中的哦,呵呵,  
  61.             //前面看到直接使用了handler 对象,是不是在找,在什么地方实例化的呢?  
  62.             //现在看到了吧???呵呵,开始的时候实例化不了,因为该线程的Looper对象  
  63.             //还不存在呢。现在可以实例化了  
  64.             //这里Looper.myLooper()获得的就是该线程的Looper对象了  
  65.             handler = new ThreadHandler(Looper.myLooper());  
  66.               
  67.             //这个方法,有疑惑吗?  
  68.             //其实就是一个循环,循环从MessageQueue中取消息。  
  69.             //不经常去看看,你怎么知道你有新消息呢???  
  70.             Looper.loop();   
  71.   
  72.         }  
  73.           
  74.         //定义线程类中的消息处理类  
  75.         class ThreadHandler extends Handler{  
  76.               
  77.             public ThreadHandler(Looper looper){  
  78.                 super(looper);  
  79.             }  
  80.               
  81.             public void handleMessage(Message msg){  
  82.                 //这里对该线程中的MessageQueue中的Message进行处理  
  83.                 //这里我们再返回给主线程一个消息  
  84.                 handler = new MyHandler(Looper.getMainLooper());  
  85.                   
  86.                 Message msg2 = handler .obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);  
  87.                   
  88.                 handler .sendMessage(msg2);  
  89.             }  
  90.         }  
  91.     }  
  92. }  

4、其他线程给自己发送Message 

Java代码   收藏代码
  1. package test.message;   
  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.view.View;  
  9. import android.widget.Button;  
  10. import android.widget.TextView;  
  11.   
  12. public class MainActivity extends Activity {   
  13.       
  14.     private Button btnTest;  
  15.     private TextView textView;  
  16.       
  17.     private Handler handler ;  
  18.       
  19.     @Override  
  20.     public void onCreate(Bundle savedInstanceState) {  
  21.         super.onCreate(savedInstanceState);  
  22.         setContentView(R.layout.main);  
  23.           
  24.         btnTest = (Button)this.findViewById(R.id.btn_01);  
  25.         textView = (TextView)this.findViewById(R.id.view_01);  
  26.           
  27.           
  28.         btnTest.setOnClickListener(new View.OnClickListener() {  
  29.               
  30.             @Override  
  31.             public void onClick(View arg0) {  
  32.                 //启动线程  
  33.                 new MyThread().start();      
  34.             }  
  35.         });  
  36.     }  
  37.       
  38.     class MyHandler extends Handler{  
  39.           
  40.         public MyHandler(Looper looper){  
  41.             super(looper);  
  42.         }  
  43.           
  44.         public void handleMessage(Message msg){  
  45.             super.handleMessage(msg);  
  46.             textView.setText((String)msg.obj);  
  47.         }  
  48.     }      
  49.       
  50.     class MyThread extends Thread{  
  51.           
  52.         public void run(){  
  53.             Looper.prepare(); //创建该线程的Looper对象  
  54.             //这里Looper.myLooper()获得的就是该线程的Looper对象了  
  55.             handler = new ThreadHandler(Looper.myLooper());  
  56.             Message msg = handler .obtainMessage(1,1,1,"我自己");  
  57.             handler .sendMessage(msg);  
  58.               
  59.             Looper.loop();   
  60.   
  61.         }  
  62.           
  63.         //定义线程类中的消息处理类  
  64.         class ThreadHandler extends Handler{  
  65.               
  66.             public ThreadHandler(Looper looper){  
  67.                 super(looper);  
  68.             }  
  69.               
  70.             public void handleMessage(Message msg){  
  71.                 //这里对该线程中的MessageQueue中的Message进行处理  
  72.                 //这里我们再返回给主线程一个消息  
  73.                 //加入判断看看是不是该线程自己发的信息  
  74.                 if(msg.what == 1 && msg.obj.equals("我自己")){  
  75.                       
  76.                     handler = new MyHandler(Looper.getMainLooper());  
  77.                       
  78.                     Message msg2 = handler .obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");  
  79.                       
  80.                     handler .sendMessage(msg2);                  
  81.                 }  
  82.   
  83.             }  
  84.         }  
  85.     }  
  86. }  


附注: 
上面四个例子的布局文件 是同一个文件main.xml 

Xml代码   收藏代码
  1. <?xml version="1.0" encoding="utf-8"?>   
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android rientation="vertical"  
  4.     android:layout_width="fill_parent"  
  5.     android:layout_height="fill_parent"  
  6.     >  
  7. <TextView  android:id="@+id/view_01"  
  8.     android:layout_width="fill_parent"   
  9.     android:layout_height="wrap_content"   
  10.     android:text="@string/hello "  
  11.     />  
  12.       
  13. <Button android:id="@+id/btn_01"   
  14.     android:layout_width="fill_parent"   
  15.     android:layout_height="wrap_content"   
  16.     android:text="测试消息" />  
  17. </LinearLayout>  


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值