A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 武汉分校-小舞 于 2016-3-15 14:02 编辑

了解Android的消息处理机制,这样有助于掌握Handler的使用原理。

一.角色描述

   
1.Looper: 一个线程可以产生一个Looper对象,由它来管理此线程里的Message Queue(消息队列)。
2.Handler: 你可以构造Handler对象来与Looper沟通,以便push新消息到Message Queue里,或者接收Looper(从Message Queue取出)所送来的消息。
3.Message Queue(消息队列),用来存放线程放入的消息。
4.线程:UI thread 通常就是main thread,而Android启动程序时会替它建立一个Message Queue。
        每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里,可以定义Handler的子类别来接收Looper所送出的消息。在你的Android程序里,新诞生一个线程,或执行 (Thread)时并不会自动建立其Message Looper。
        Android里并没有Global的Message Queue数据结构,例如,不同APK里的对象不能透过Massage Queue来交换讯息(Message)。
        例如:线程A的Handler对象可以传递消息给别的线程,让别的线程B或C等能送消息来给线程A(存于A的Message Queue里)。线程A的Message Queue里的消息,只有线程A所属的对象可以处理。使用Looper.myLooper()可以取得当前线程的Looper对象。可以自定义Handler类,只要继承Handler即可。使用new EventHandler(Looper.myLooper()); 可用来构造当前线程的Handler对象(其中EventHandler是自定义的Handler类)。

二.举例
   
1.
同线程内不同组件间的消息传递
        Looper类用来管理特定线程内对象之间的消息交换(MessageExchange)。你的应用程序可以产生许多个线程。而一个线程可以有许多个组件,这些组件之间常常需要互相交换讯息。如果有这种需要,您可以替线
程构造一个Looper对象,来担任讯息交换的管理工作。Looper对象会建立一个MessageQueue数据结构来存放各对象传来的消息(包括UI事件或System事件等)。每一个线程里可含有一个Looper对象以及一个
MessageQueue数据结构。在你的应用程序里,可以定义Handler的子类别来接收Looper所送出的消息。
同线程不同组件之间的消息传递代码如下:
public classHandlerActivity extends Activity {  
                 private Button sendBtn;  
                 private TextView tv;  
               
                 @Override  
                 protected void onCreate(Bundle savedInstanceState) {  
                     super.onCreate(savedInstanceState);
                      setContentView(R.layout.main);  
                      sendBtn = (Button) findViewById(R.id.send);  
                      tv = (TextView)findViewById(R.id.textview);  
                      sendBtn.setOnClickListener(newMyOnClickListener());  
                 }  
               
                 class MyOnClickListener implements OnClickListener {  
                      @Override  
                      public void onClick(View v) {  
                          switch (v.getId()) {  
                          case R.id.send:  
                              // 取得当前线程的Looper,此时的线程为主线程(UI线程)  
                              Looper looper =Looper.myLooper();  
                              // 构造一个Handler对象使之与Looper通信  
                              MyHandler mHandler = newMyHandler(looper);  
                              // 产生一个消息通过Handler传递给Looper  
                              String msgStr ="main";  
                          // 构造一个消息,这里what参数设为1obj参数设为msgStr变量。  
                              Message msg =mHandler.obtainMessage(1, 1, 1, msgStr);
                              // 发送消息,调用Handler对象的handleMessage方法
                              mHandler.sendMessage(msg);  
                              break;  
                          }
                      }
                 }  
               
                  // 自定义Handler
                 class MyHandler extends Handler {
                      // 指定Looper对象来构造Handler对象,而我们平时直接使用的Handler无参构造方法实际上默认是本线程的looper,可通过查看SDk源代码了解。  
                      public MyHandler(Looper looper) {  
                          super(looper);  
                      }
                      @Override  
                      public void handleMessage(Message msg){  
                          switch (msg.what) {  
                          case 1:  
                             tv.setText(String.valueOf(msg.obj));
                              break;  
               
                          }
                      }
                 }  
              }
说明:
        此程序启动时,当前线程(即主线程, mainthread)已诞生了一个Looper对象,并且有了一个MessageQueue数据结构。
①调用Looper类别的静态myLooper()函数,以取得目前线程里的Looper对象。
looper = Looper.myLooper ();
②构造一个MyHandler对象来与Looper沟通。Activity等对象可以藉由MyHandler对象来将消息传给Looper,然后放入MessageQueue里;MyHandler对象也扮演Listener的角色,可接收Looper对象所送来的消息。
mHandler = new MyHandler (looper);
③先构造一个Message对象,并将数据存入对象里。
Message msg = mHandler.obtainMessage(1, 1, 1, msgStr);
这里也可以这样写:
Message msg = new Message();
msg.what = 1;
msg.obj = msgStr;
④通过mHandler对象将消息m传给Looper,然后放入MessageQueue里。
mHandler.sendMessage(msg);
        此时,Looper对象看到MessageQueue里有消息m,就将它广播出去,mHandler对象接到此讯息时,会调用其handleMessage()函数来处理,于是让msgStr显示于TextView上(更新UI)。

2.子线程传递消息给主线程

代码如下:
public classHandlerActivity extends Activity {  
                 private Button sendBtn;  
                 private TextView tv;  
                 private MyHandler mHandler = null;
                 Thread thread;  
               
                 @Override  
                 protected void onCreate(Bundle savedInstanceState) {  
                     super.onCreate(savedInstanceState);
                      setContentView(R.layout.main);  
                      sendBtn = (Button)findViewById(R.id.send);  
                      tv = (TextView)findViewById(R.id.textview);  
                      sendBtn.setOnClickListener(newMyOnClickListener());  
                 }  
               
                 class MyOnClickListener implements OnClickListener {  
                      @Override  
                      public void onClick(View v) {  
                          switch (v.getId()) {  
                          case R.id.send:  
                              thread = new MyThread();  
                              thread.start();  
                              break;  
                          }
                      }
                 }  
               
                 // 自定义Handler
                 class MyHandler extends Handler {
                      // 指定Looper对象来构造Handler对象,而我们平时直接使用的Handler无参构造方法实际上默认是本线程的looper,可通过查看SDk源代码了解。  
                      public MyHandler(Looper looper) {  
                          super(looper);  
                      }
               
                      @Override  
                      public void handleMessage(Message msg){  
                          switch (msg.what) {  
                          case 1:  
                              tv.setText(String.valueOf(msg.obj));  
                              break;  
               
                          }
                      }
                 }  
               
                 private class MyThread extends Thread {
                      @Override  
                      public void run() {  
                          // 获得当前线程的Looper对象  
                          Looper curLooper =Looper.myLooper();  
                          // 获得主线程(UI线程)的Looper对象  
                          Looper mainLooper =Looper.getMainLooper();  
                          String msgStr;  
                          if (curLooper == null) {  
                              mHandler = newMyHandler(mainLooper);  
                              msgStr = "curLooper isnull";  
                          } else {  
                              mHandler = newMyHandler(curLooper);  
                              msgStr = "This iscurLooper";  
                          }
                          Message msg =mHandler.obtainMessage(1, 1, 1, msgStr);
                          mHandler.sendMessage(msg);  
                      }
                 }  
              }
说明:
        Android会自动替主线程建立MessageQueue。在这个子线程里并没有建立Message Queue。所以curLooper值为null,而mainLooper则指向主线程里的Looper。于是执行mHandler= new MyHandler (mainLooper);mHandler属于主线程。
        mHandler.sendMessage(msg);
就将msg消息存入到主线程的MessageQueue里。
        mainLooper
看到Message Queue里有讯息,就会作出处理,于是由主线程执行到mHandlerhandleMessage()来处理消息。

本帖持续跟新,想最快获最新独家分享请加QQ  1641907557 后期会分享更多与实体班同步教程,助你冲击月薪20K!





推荐阅读:



0 个回复

您需要登录后才可以回帖 登录 | 加入黑马