handle消息机制

一、几个关键概念

1、MessageQueue:是一种 数据 结构,见名知义,就是一个消息队列,存放消息的地方。每一个线程最多只可以拥有一个MessageQueue数据结构。
创建一个线程的时候,并不会自动 创建其MessageQueue。通常使用一个Looper对象对该线程的MessageQueue进行管理。主线程创建时,会创建一个默认的Looper对象,而Looper对象的创建,将自动创建一个Message Queue。其他非主线程,不会自动创建Looper,要需要的时候,通过调用prepare函数来实现。

2、Message:消息对象,Message Queue中的存放的对象。一个Message Queue中包含多个Message。
Message实例对象的取得,通常使用Message类里的静态方法obtain(),该方法有多个重载版本可供选择;它的创建并不一定是直接创建一个新的实例,而是先从Message Pool(消息池)中看有没有可用的Message实例,存在则直接取出返回这个实例。如果Message Pool中没有可用的Message实例,则才用给定的参数创建一个Message对象。调用removeMessages()时,将Message从Message Queue中删除,同时放入到Message Pool中。除了上面这种方式,也可以通过Handler对象的obtainMessage()获取 一个Message实例。

3、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中。

4、Handler:
消息的处理者,handler 负责将需要传递的信息封装成Message,通过调用handler 对象的obtainMessage()来实现;
将消息传递给Looper,这是通过handler 对象的sendMessage()来实现的。继而由Looper将Message放入MessageQueue中。
当Looper对象看到MessageQueue中含有Message,就将其广播出去。该handler 对象收到该消息后,调用相应的handler 对象的handleMessage()方法对其进行处理。

 

二、工作流程

1、首先Looper.prepare()在本线程中保存一个Looper实例,然后该实例中保存一个MessageQueue对象;因为Looper.prepare()在一个线程中只能调用一次,所以MessageQueue在一个线程中只会存在一个。

2、Looper.loop()会让当前线程进入一个无限循环,不端从MessageQueue的实例中读取消息,然后回调msg.target.dispatchMessage(msg)方法。

3、Handler的构造方法,会首先得到当前线程中保存的Looper实例,进而与Looper实例中的MessageQueue想关联。

4、Handler的sendMessage方法,会给msg的target赋值为handler自身,然后加入MessageQueue中。

5、在构造Handler实例时,我们会重写handleMessage方法,也就是msg.target.dispatchMessage(msg)最终调用的方法。


三、实际操作

1、主线程给自己发送Message

Java代码 

  1. public class MainActivity extends Activity {   
  2.       
  3.     private Button btnTest;  
  4.     private TextView textView;  
  5.       
  6.     private Handler handler ;  
  7.       
  8.     @Override  
  9.     public void onCreate(Bundle savedInstanceState) {  
  10.         super.onCreate(savedInstanceState);  
  11.         setContentView(R.layout.main);  
  12.           
  13.         btnTest = (Button)this.findViewById(R.id.btn_01);  
  14.         textView = (TextView)this.findViewById(R.id.view_01);  
  15.           
  16.         btnTest.setOnClickListener(new View.OnClickListener() {  
  17.               
  18.             @Override  
  19.             public void onClick(View arg0) {  
  20.                   
  21.                 Looper looper = Looper.getMainLooper(); //主线程的Looper对象  
  22.                 //这里以主线程的Looper对象创建了handler ,  
  23.                 //所以,这个handler 发送的Message会被传递给主线程的MessageQueue。  
  24.                 handler = new MyHandler(looper);  
  25.                 handler .removeMessages(0);  
  26.                 //构建Message对象  
  27.                 //第一个参数:是自己指定的message代号,方便在handler 选择性地接收  
  28.                 //第二三个参数没有什么意义  
  29.                 //第四个参数需要封装的对象  
  30.                 Message msg = handler .obtainMessage(1,1,1,"主线程发消息了");  
  31.                   
  32.                 handler .sendMessage(msg); //发送消息  
  33.                   
  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("我是主线程的Handler,收到了消息:"+(String)msg.obj);  
  47.         }  
  48.     }  
  49. }  


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

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



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

           public class MainActivity extends Activity {         

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


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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值