【安卓面试笔记】Handler(三)

来源:互联网 发布:win7仿mac任务栏 编辑:程序博客网 时间:2024/05/21 20:38

1. Handler(管理者)的理解

     主要接受子线程的数据,然后将数据获取配合主线程改变UI。做到和用户的交互

  引用下其他大神的解释及介绍:

  1. 当应用程序启动时,Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件,进行事件分发, 比如说, 你要是点击一个 Button ,Android会分发事件到Button上,来响应你的操作。  如果此时需要一个耗时的操作,例如: 联网读取数据,    或者读取本地较大的一个文件的时候,你不能把这些操作放在主线程中,,如果你放在主线程中的话,界面会出现假死现象, 如果5秒钟还没有完成的话,,会收到Android系统的一个错误提示  "强制关闭".  这个时候我们需要把这些耗时的操作,放在一个子线程中,因为子线程涉及到UI更新,,Android主线程是线程不安全的,也就是说,更新UI只能在主线程中更新,子线程中操作是危险的. 这个时候,Handler就出现了.,来解决这个复杂的问题 ,    由于Handler运行在主线程中(UI线程中),  它与子线程可以通过Message对象来传递数据, 这个时候,Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象,(里面包含数据)  , 把这些消息放入主线程队列中,配合主线程进行更新UI。

     2.消息的处理者。通过Handler对象我们可以封装Message对象,然后通过sendMessage(msg)把Message对象添加到MessageQueue中;当MessageQueue循环到该Message时,就会调用该Message对象对应的handler对象的handleMessage()方法对其进行处理。由于是在handleMessage()方法中处理消息,因此我们应该编写一个类继承自Handler,然后在handleMessage()处理我们需要的操作。


2.Handler 的作用

  毋庸置疑,Handler的作用基本可以用一句概括“获取数据配合主线程更新UI”

那么他又是怎么做到的呢?在回答这个问题之前,我们需要了解Handler的特点:

特点如下:handler可以发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),

       message对象和runnable就是协助它的。

这是网上的一个实例:

 

  1. public class MainActivity extends Activity {  
  2.   
  3.     TextView tv;  
  4.     int count=0;  
  5.     //处理从工作线程发送过来的消息  
  6.     Handler handler=new Handler(){  
  7.         public void handleMessage(android.os.Message msg) {  
  8.             int num=msg.arg1;  
  9.             tv.setText(num+"");  
  10.               
  11.             //int a1=msg.arg1;  
  12.             int a2=msg.arg2;  
  13.             String a3=(String) msg.obj;  
  14.             int a4=msg.what;  
  15.             String a5=msg.getData().getString("str");  
  16.             Toast.makeText(getApplicationContext(),   
  17.   "整型:a2="+a2+"\n传过来的对象:a3="+a3+"\n标记:a4="+a4+"\nBundle对象数据:a5="+a5, 0).show();  
  18.         };  
  19.     };  
  20.     @Override  
  21.     protected void onCreate(Bundle savedInstanceState) {  
  22.         super.onCreate(savedInstanceState);  
  23.         setContentView(R.layout.activity_main);  
  24.         tv=(TextView) findViewById(R.id.tv);  
  25.           
  26.         new Thread(){  
  27.             public void run() {  
  28.                 while(true)  
  29.                 {  
  30.                     if(count<50)  
  31.                     {  
  32.                         count++;  
  33.                     }  
  34.                     //得到Message对象  
  35.                     //Message msg=Message.obtain();  
  36.                     Message msg=handler.obtainMessage();  
  37.                     msg.arg1=count;//将值封装到msg,携带过去  
  38.                     handler.sendMessage(msg);  
  39.                     try {  
  40.                         Thread.sleep(2000);  
  41.                     } catch (InterruptedException e) {  
  42.                         // TODO Auto-generated catch block  
  43.                         e.printStackTrace();  
  44.                     }  
  45.                 }  
  46.             };  
  47.         }.start();  
  48.     }  
  49.   
  50.     public void click(View v)  
  51.     {  
  52.         new Thread(){  
  53.             public void run() {  
  54.                 Message msg1=Message.obtain();  
  55.                 //msg1.arg1=100;  
  56.                 msg1.arg2=200;  
  57.                 msg1.obj="wwwdfr";  
  58.                 msg1.what=3;//标记  
  59.                   
  60.                 Bundle bundle=new Bundle();  
  61.                 bundle.putString("str""大数据");  
  62.                 msg1.setData(bundle);  
  63.                 handler.sendMessage(msg1);  
  64.             };  
  65.         }.start();  
  66.     }  
  67.       
  68. }  
我们可以从代码中看到,他的主要流程如下:


    开始点击: (生成Message对象,并放入数据,如之前所说,其中有整型,字符型,甚至是对象bundle)
  1.  Message msg1=Message.obtain();  
  2.                 //msg1.arg1=100;  
  3.                 msg1.arg2=200;  
  4.                 msg1.obj="wwwdfr";  
  5.                 msg1.what=3;//标记  
  6.                   
  7.                 Bundle bundle=new Bundle();  
  8.                 bundle.putString("str""大数据");  
  9.                 msg1.setData(bundle);  
  10.                 handler.sendMessage(msg1);


另外我们可以注意到:(在主线程下,还有个子线程在运行)arg1被改动
  1.   new Thread(){  
  2.             public void run() {  
  3.                 while(true)  
  4.                 {  
  5.                     if(count<50)  
  6.                     {  
  7.                         count++;  
  8.                     }  
  9.                     //得到Message对象  
  10.                     //Message msg=Message.obtain();  
  11.                     Message msg=handler.obtainMessage();  
  12.                     msg.arg1=count;//将值封装到msg,携带过去  
  13.                     handler.sendMessage(msg);  
  14.                     try {  
  15.                         Thread.sleep(2000);  
  16.                     } catch (InterruptedException e) {  
  17.                         // TODO Auto-generated catch block  
  18.                         e.printStackTrace();  
  19.                     }  
  20.                 }  
  21.             };  
  22.         }.start();  
最后看:
  1.  //处理从工作线程发送过来的消息  
  2.     Handler handler=new Handler(){  
  3.         public void handleMessage(android.os.Message msg) {  
  4.             int num=msg.arg1;  
  5.             tv.setText(num+"");  
  6.               
  7.             //int a1=msg.arg1;  
  8.             int a2=msg.arg2;  
  9.             String a3=(String) msg.obj;  
  10.             int a4=msg.what;  
  11.             String a5=msg.getData().getString("str");  
  12.             Toast.makeText(getApplicationContext(),   
  13.   "整型:a2="+a2+"\n传过来的对象:a3="+a3+"\n标记:a4="+a4+"\nBundle对象数据:a5="+a5, 0).show();  
  14.         };  
  15.     };  
子线程中的信息都可以获取。实现了handler配合主线程更新UI

1 0
原创粉丝点击