码迷，mamicode.com
首页 > 其他好文 > 详细

Handle机制详解

时间：2014-08-23 20:22:33      阅读：254      评论：0      收藏：0      [点我收藏+]

标签：des   android   style   blog   http   java   os   使用   io   

原文地址：http://blog.csdn.net/kakaxi1o1/article/details/12278499

 

一、Android消息机制一

         Android 有一种叫消息队列的说法，这里我们可以这样理解：假如一个隧道就是一个消息队列，那么里面的每一部汽车就是一个一个消息，这里我们先忽略掉超车等种种因素，只那么先进隧道的车将会先出，这个机制跟我们android 的消息机制是一样的。

角色描述

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 Loop 。

Android 里并没有Global 的Message Queue 数据结构，例如，不同APK 里的对象不能透过Massage Queue来交换讯息(Message) 。

例如：线程A 的Handler 对象可以传递消息给别的线程，让别的线程B 或C 等能送消息来给线程A( 存于A的Message Queue 里) 。

线程A 的Message Queue 里的讯息，只有线程A 所属的对象可以处理。

使用Looper.myLooper 可以取得当前线程的Looper 对象。

使用mHandler = new EevntHandler(Looper.myLooper()); 可用来构造当前线程的Handler 对象；其中，EevntHandler 是自已实现的Handler 的子类别。

使用mHandler = new EevntHandler(Looper.getMainLooper()); 可诞生用来处理main 线程的Handler 对象；其中，EevntHandler 是自已实现的Handler 的子类别。

1.  同线程内不同组件间的消息传递

Looper 类用来管理特定线程内对象之间的消息交换(Message Exchange) 。你的应用程序可以产生许多个线程。而一个线程可以有许多个组件，这些组件之间常常需要互相交换讯息。如果有这种需要，您可以替线程构造一个Looper 对象，来担任讯息交换的管理工作。Looper 对象会建立一个MessageQueue 数据结构来存放各对象传来的消息( 包括UI 事件或System 事件等) 。

 

每一个线程里可含有一个Looper 对象以及一个MessageQueue 数据结构。在你的应用程序里，可以定义Handler 的子类别来接收Looper 所送出的消息。

同线程不同组件之间的消息传递：

举例：

 

 

[java] view plaincopy
 
  1. public class Activity1 extends Activity implements OnClickListener{  
  2.        Button button = null ;  
  3.        TextView text = null ;  
  4.        @Override  
  5.        protected void onCreate(Bundle savedInstanceState) {  
  6.               super .onCreate(savedInstanceState);  
  7.               setContentView(R.layout.activity1 );          
  8.               button = (Button)findViewById(R.id.btn );  
  9.               button.setOnClickListener(this );  
  10.               text = (TextView)findViewById(R.id.content );  
  11.        }  
  12.        public void onClick(View v) {  
  13.               switch (v.getId()) {  
  14.               case R.id.btn :  
  15.                      Looper looper = Looper.myLooper();//取得当前线程里的looper  
  16.                      MyHandler mHandler = new MyHandler(looper);//构造一个handler使之可与looper通信  
  17.                      //buton等组件可以由mHandler将消息传给looper后,再放入messageQueue中,同时mHandler也可以接受来自looper消息  
  18.                      mHandler.removeMessages(0);  
  19.                      String msgStr = "主线程不同组件通信:消息来自button";  
  20.                      Message m = mHandler.obtainMessage(1, 1, 1, msgStr);//构造要传递的消息  
  21.                      mHandler.sendMessage(m);//发送消息:系统会自动调用handleMessage方法来处理消息  
  22.                      break ;  
  23.                }              
  24.        }       
  25.        private class MyHandler extends Handler{               
  26.               public MyHandler(Looper looper){  
  27.                      super (looper);  
  28.               }  
  29.               @Override  
  30.               public void handleMessage(Message msg) {//处理消息  
  31.                      text.setText(msg.obj.toString());  
  32.               }              
  33.        }  
  34. }  

 

[java] view plaincopy
 
  1.   

   说明：

此程序启动时，当前线程( 即主线程, main thread) 已诞生了一个Looper 对象，并且有了一个MessageQueue数据结构。

 

[java] view plaincopy
 
  1. looper = Looper.myLooper ();   

 

调用Looper 类别的静态myLooper() 函数，以取得目前线程里的Looper 对象.

 

[java] view plaincopy
 
  1. mHandler = new MyHandler (looper);  

 

构造一个MyHandler 对象来与Looper 沟通。Activity 等对象可以藉由MyHandler 对象来将消息传给Looper ，然后放入MessageQueue 里；MyHandler 对象也扮演Listener 的角色，可接收Looper 对象所送来的消息。

 

[java] view plaincopy
 
  1. Message m = mHandler.obtainMessage(1, 1, 1, obj);  

 

先构造一个Message 对象，并将数据存入对象里。

 

[java] view plaincopy
 
  1. mHandler.sendMessage(m);  

 

就透过mHandler 对象而将消息m 传给Looper ，然后放入MessageQueue 里。

此时，Looper 对象看到MessageQueue 里有消息m ，就将它广播出去，mHandler 对象接到此讯息时，会呼叫其handleMessage() 函数来处理，于是输出"This my message!" 于画面上

 

[java] view plaincopy
 
  1. public class Activity1 extends Activity implements OnClickListener{  
  2.        Button button = null ;  
  3.        TextView text = null ;  
  4.        @Override  
  5.        protected void onCreate(Bundle savedInstanceState) {  
  6.               super .onCreate(savedInstanceState);  
  7.               setContentView(R.layout.activity1 );          
  8.               button = (Button)findViewById(R.id.btn );  
  9.               button.setOnClickListener(this );  
  10.               text = (TextView)findViewById(R.id.content );  
  11.        }  
  12.        public void onClick(View v) {  
  13.               switch (v.getId()) {  
  14.               case R.id.btn :  
  15.                      Looper looper = Looper.myLooper();//取得当前线程里的looper  
  16.                      MyHandler mHandler = new MyHandler(looper);//构造一个handler使之可与looper通信  
  17.                      //buton等组件可以由mHandler将消息传给looper后,再放入messageQueue中,  
  18.              //同时mHandler也可以接受来自looper消息  
  19.                      mHandler.removeMessages(0);  
  20.                      String msgStr = "主线程不同组件通信:消息来自button";  
  21.                      Message m = mHandler.obtainMessage(1, 1, 1, msgStr);//构造要传递的消息  
  22.                      mHandler.sendMessage(m);//发送消息:系统会自动调用handleMessage方法来处理消息  
  23.                      break ;  
  24.                }              
  25.        }       
  26.        private class MyHandler extends Handler{               
  27.               public MyHandler(Looper looper){  
  28.                      super (looper);  
  29.               }  
  30.               @Override  
  31.               public void handleMessage(Message msg) {//处理消息  
  32.                      text.setText(msg.obj.toString());  
  33.               }              
  34.        }  
  35. }  

 

 

二、Android消息机制二

 

角色综述（回顾）

   

1. UI thread 通常就是main thread ，而Android 启动程序时会替它建立一个MessageQueue 。

2. 当然需要一个Looper 对象，来管理该MessageQueue 。

3. 我们可以构造Handler 对象来push 新消息到Message Queue 里；或者接收Looper( 从Message Queue取出) 所送来的消息。

4. 线程A 的Handler 对象可以传递给别的线程，让别的线程B 或C 等能送讯息来给线程A( 存于A 的Message Queue 里) 。

5. 线程A 的Message Queue 里的消息，只有线程A 所属的对象可以处理。

 

子线程传递消息给主线程

举例

[java] view plaincopy
 
  1. public class Activity2 extends Activity implements OnClickListener{  
  2.        Button button = null ;  
  3.        TextView text = null ;  
  4.        MyHandler mHandler = null ;  
  5.        Thread thread ;  
  6.        @Override  
  7.        protected void onCreate(Bundle savedInstanceState) {  
  8.               super .onCreate(savedInstanceState);  
  9.               setContentView(R.layout.activity1 );          
  10.               button = (Button)findViewById(R.id.btn );  
  11.               button.setOnClickListener(this );  
  12.               text = (TextView)findViewById(R.id.content );  
  13.        }  
  14.        public void onClick(View v) {  
  15.               switch (v.getId()) {  
  16.               case R.id.btn :  
  17.                      thread = new MyThread();  
  18.                      thread.start();  
  19.                      break ;  
  20.               }              
  21.        }       
  22.        private class MyHandler extends Handler{               
  23.               public MyHandler(Looper looper){  
  24.                      super (looper);  
  25.               }  
  26.               @Override  
  27.               public void handleMessage(Message msg) {//处理消息  
  28.                      text.setText(msg.obj.toString());  
  29.               }              
  30.        }  
  31.        private class MyThread extends Thread{  
  32.               @Override  
  33.               public void run() {  
  34.                      Looper curLooper = Looper.myLooper();  
  35.                      Looper mainLooper = Looper.getMainLooper();  
  36.                      String msg ;  
  37.                      if (curLooper==null ){  
  38.                             mHandler = new MyHandler(mainLooper);  
  39.                             msg = "curLooper is null";  
  40.                      }else {  
  41.                             mHandler = new MyHandler(curLooper);  
  42.                             msg = "This is curLooper";  
  43.                      }  
  44.                      mHandler.removeMessages(0);  
  45.                      Message m = mHandler.obtainMessage(1, 1, 1, msg);  
  46.                      mHandler.sendMessage(m);  
  47.               }              
  48.        }  
  49. }  

 

说明：

Android 会自动替主线程建立Message Queue 。在这个子线程里并没有建立Message Queue 。所以，myLooper 值为null ，而mainLooper 则指向主线程里的Looper 。于是，执行到：

 

[java] view plaincopy
 
  1. mHandler = new MyHandler (mainLooper);  

 

此mHandler 属于主线程。

 

[java] view plaincopy
 
  1. mHandler.sendMessage(m);  

 

就将m 消息存入到主线程的Message Queue 里。mainLooper 看到Message Queue 里有讯息，就会作出处理，于是由主线程执行到mHandler 的handleMessage() 来处理消息。

三、用Android线程间通信的Message机制

在Android 下面也有多线程 的概念，在C/C++中，子线程可以是一个函数 ，一般都是一个带有循环的函数，来处理某些数据 ，优先线程只是一个复杂的运算过程，所以可能不需要while循环，运算完成，函数结束，线程就销毁。对于那些需要控制的线程，一般我们都是和互斥锁相互关联，从而来控制线程的进度，一般我们创建子线程，一种线程是很常见的，那就是带有消息循环的线程。
消息循环是一个很有用的线程方式，曾经自己用C在Linux下面实现一个消息循环的机制 ，往消息队列里添加数据，然后异步的等待消息的返回。当消息队列为空的时候就会挂起线程，等待新的消息的加入。这是一个很通用的机制。
在 Android，这里的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper，这个事android的新概念。我 们的主线程（UI线程）就是一个消息循环的线程。针对这种消息循环的机制，我们引入一个新的机制Handle，我们有消息循环，就要往消息循环里面发送相 应的消息，自定义 消息一般都会有自己对应的处理，消息的发送和清除，消息的的处理，把这些都封装在Handle里面，注意Handle只是针对那些有Looper的线程，不管是UI线程还是子线程，只要你有Looper，我就可以往你的消息队列里面添加东西，并做相应的处理。
但是这里还有一点，就是只要是关于UI相关的东西，就不能放在子线程中，因为子线程是不能操作UI的，只能进行数据、系统 等其他非UI的操作。
那么什么情况下面我们的子线程才能看做是一个有Looper的线程呢？我们如何得到它Looper的句柄呢？
Looper.myLooper();            //获得当前的Looper
Looper.getMainLooper () ;  //获得UI线程的Lopper
我们看看Handle的初始化函数，如果没有参数，那么他就默认使用的是当前的Looper，如果有Looper参数，就是用对应的线程的Looper。
如 果一个线程中调用Looper.prepare()，那么系统就会自动的为该线程建立一个消息队列，然后调用 Looper.loop();之后就进入了消息循环，这个之后就可以发消息、取消息、和处理消息。这个如何发送消息和如何处理消息可以再其他的线程中通过 Handle来做，但前提是我们的Hanle知道这个子线程的Looper，但是你如果不是在子线程运行 Looper.myLooper()，一般是得不到子线程的looper的。

 

[java] view plaincopy
 
  1. public void run() {  
  2. <span style="white-space:pre">  </span>synchronized (mLock) {  
  3.    <span style="white-space:pre">       </span>Looper.prepare();  
  4.       <span style="white-space:pre">        </span>//do something  
  5.         }  
  6.         Looper.loop();  
  7. }  

所以很多人都是这样做的：我直接在子线程中新建handle，然后在子线程中发送消息，这样的话就失去了我们多线程的意义了。

 

 

[java] view plaincopy
 
  1. class myThread extends Thread{  
  2.              private EHandler mHandler ;  
  3.              public void run() {  
  4.                  Looper myLooper, mainLooper;  
  5.                  myLooper = Looper.myLooper ();  
  6.                 mainLooper = Looper.getMainLooper ();  
  7.                 String obj;  
  8.                 if (myLooper == null ){  
  9.                          mHandler = new EHandler(mainLooper);  
  10.                          obj = "current thread has no looper!" ;  
  11.                 }  
  12.                 else {  
  13.                      mHandler = new EHandler(myLooper);  
  14.                      obj = "This is from current thread." ;  
  15.                 }  
  16.                 mHandler .removeMessages(0);  
  17.                 Message m = mHandler .obtainMessage(1, 1, 1, obj);  
  18.                 mHandler .sendMessage(m);  
  19.              }  
  20.   }  


可以让其他的线程来控制我们的handle，可以把 private EHandler mHandler ;放在外面，这样我们的发消息和处理消息都可以在外面来定义，这样增加程序 代码 的美观，结构更加清晰。
对如任何的Handle，里面必须要重载一个函数
public void handleMessage(Message msg)
这个函数就是我们的消息处理，如何处理，这里完全取决于你，然后通过 obtainMessage和 sendMessage等来生成和发送消息， removeMessages(0)来清除消息队列。Google 真是太智慧了，这种框架 的产生，我们写代码更加轻松了。
有的时候，我们的子线程想去改变UI了，这个时候千万不要再子线程中去修改，获得UI线程的Looper，然后发送消息即可。
我们看看Goole Music App的源代码 。
在MediaPlaybackActivity.java 中，我们可以看一下再OnCreate中的有这样的两句：

[java] view plaincopy
 
  1. mAlbumArtWorker = new Worker("album art worker");  
  2. mAlbumArtHandler = new AlbumArtHandler(mAlbumArtWorker.getLooper());  

很 明显这两句，是构建了一个子线程。并且这个子线程还是Looper的子线程，这里很牛逼的使用了 mAlbumArtWorker.getLooper()这个函数，因为我们知道，我们能够得到子线程的Looper的途径只有一个：就是在子线程中调用 Looper.myLooper ()，并且这个函数还要在我们perpare之后调用才能得到正确的Looper，但是他这里用了一个这样的什么东东 getLooper，不知道它是如何实现的？
这里有一个大概的思路，我们在子线程的的prepare之后调用 myLooper ()这个方法，然后保存在一个成员变量中，这个getLooper就返回这个东西，但是这里会碰到多线程的一个很突出的问题，同步。我们在父线程中调用 mAlbumArtWorker.getLooper()，但是想要这个返回正确的looper就必须要求我们的子线程运行了prepare，但是这个东 西实在子线程运行的，我们如何保证呢？
我们看Google是如何实现的？

 

 

[java] view plaincopy
 
  1. private class Worker implements Runnable {  
  2.         private final Object mLock = new Object();  
  3.         private Looper mLooper;  
  4.           
  5.         /** 
  6.          * Creates a worker thread with the given name. The thread 
  7.          * then runs a [email=%7B@link]{@link [/email] android.os.Looper}. 
  8.          * @param name A name for the new thread 
  9.          */  
  10.         Worker(String name) {  
  11.             Thread t = new Thread(null, this, name);  
  12.             t.setPriority(Thread.MIN_PRIORITY);  
  13.             t.start();  
  14.             synchronized (mLock) {  
  15.                 while (mLooper == null) {  
  16.                     try {  
  17.                         mLock.wait();  
  18.                     } catch (InterruptedException ex) {  
  19.                     }  
  20.                 }  
  21.             }  
  22.         }  
  23.           
  24.         public Looper getLooper() {  
  25.             return mLooper;  
  26.         }  
  27.           
  28.         public void run() {  
  29.             synchronized (mLock) {  
  30.                 Looper.prepare();  
  31.                 mLooper = Looper.myLooper();  
  32.                 mLock.notifyAll();  
  33.             }  
  34.             Looper.loop();  
  35.         }  
  36.           
  37.         public void quit() {  
  38.             mLooper.quit();  
  39.         }  
  40.     }  

我 们知道，一个线程类的构造函数是在主线程中完成的，所以在我们的 Worker的构造函数中我们创佳一个线程，然后让这个线程运行，这一这个线程的创建是指定一个 Runnable，这里就是我们的Worker本身，在主线程调用 t.start();，这后，我们子线程已经创建，并且开始执行work的run方法。然后下面的代码很艺术：

[java] view plaincopy
 
  1. synchronized (mLock) {  
  2.                 while (mLooper == null) {  
  3.                     try {  
  4.                         mLock.wait();  
  5.                     } catch (InterruptedException ex) {  
  6.                     }  
  7.                 }  
  8.             }  


我们开始等待我们的子线程给mLooper赋值，如果不赋值我们就继续等，然后我们的子线程在运行run方法之后，在给 mLooper赋值之后，通知worker够着函数中的wait，然后我们的构造函数才能完成，所以我们说：

[java] view plaincopy
 
  1. mAlbumArtWorker = new Worker("album art worker");  

这句本身就是阻塞的，它创建了一个子线程，开启了子线程，并且等待子线程给mLooper赋值，赋值完成之后，这个函数才返回，这样才能保证我们的子线程的Looper的获取 绝对是正确的，这个构思很有创意。值得借鉴。

 

 

四、Android中Handler的使用方法——在子线程中更新界面

 

本文主要介绍Android的Handler的使用方法。Handler可以发送Messsage和Runnable对象到与其相关联的线程的消息队列。每个Handler对象与创建它的线程相关联，并且每个Handler对象只能与一个线程相关联。

1.    Handler一般有两种用途：

1）执行计划任务，你可以再预定的实现执行某些任务，可以模拟定时器。

2）线程间通信。在Android的应用启动时，会 创建一个主线程，主线程会创建一个消息队列来处理各种消息。

当你创建子线程时，你可以再你的子线程中拿到父线程中创建的Handler对象，就可以通过该 对象向父线程的消息队列发送消息了。由于Android要求在UI线程中更新界面，因此，可以通过该方法在其它线程中更新界面。 

◆ 通过Runnable在子线程中更新界面

1)在onCreate中创建Handler 

 

[java] view plaincopy
 
  1. public class HandlerTestApp extends Activity {   
  2.         Handler mHandler;   
  3.         TextView mText;   
  4.         /** Called when the activity is first created. */   
  5.        @Override   
  6.        public void onCreate(Bundle savedInstanceState) {   
  7.            super.onCreate(savedInstanceState);   
  8.            setContentView(R.layout.main);   
  9.            mHandler = new Handler();//创建Handler   
  10.            mText = (TextView) findViewById(R.id.text0);//一个TextView   
  11.        }   

2) 构建Runnable对象，在runnable中更新界面，此处，我们修改了TextView的文字.此处需要说明的是，Runnable对象可以再主线程中创建，也可以再子线程中创建。我们此处是在子线程中创建的。   

 

 

[java] view plaincopy
 
  1. Runnable mRunnable0 = new Runnable()   
  2.     {   
  3.                 @Override   
  4.                 public void run() {   
  5.                         mText.setText("This is Update from ohter thread, Mouse DOWN");   
  6.                 }   
  7.     };   

3)   创建子线程，在线程的run函数中，我们向主线程的消息队列发送了一个runnable来更新界面。

 

 

[java] view plaincopy
 
  1. private void updateUIByRunnable(){   
  2.           new Thread()    
  3.          {    
  4.                //Message msg = mHandler.obtainMessage();    
  5.               public void run()    
  6.              {   
  7.   
  8.                    //mText.setText("This is Update from ohter thread, Mouse DOWN");//这句将抛出异常   
  9.                    mHandler.post(mRunnable0);    
  10.              }    
  11.          }.start();  
  12.   
  13.      }  

◆ 用Message在子线程中来更新界面

 

用Message更新界面与Runnable更新界面类似，只是需要修改几个地方。

1) 实现自己的Handler，对消息进行处理

 

[java] view plaincopy
 
  1. private class MyHandler extends Handler   
  2.     {   
  3.   
  4.         @Override   
  5.         public void handleMessage(Message msg) {   
  6.             super.handleMessage(msg);   
  7.             switch(msg.what)   
  8.             {   
  9.             case UPDATE ://在收到消息时，对界面进行更新   
  10.                 mText.setText("This update by message");   
  11.                 break;   
  12.             }   
  13.         }   
  14.     }  

2)  在新的线程中发送消息  

 

 

[java] view plaincopy
 
  1. private void updateByMessage()   
  2.     {   
  3.         //匿名对象   
  4.          new Thread()   
  5.          {   
  6.                 public void run()   
  7.                 {   
  8.                     //mText.setText("This is Update from ohter thread, Mouse DOWN");  
  9.   
  10.                     //UPDATE是一个自己定义的整数，代表了消息ID   
  11.                     Message msg = mHandler.obtainMessage(UPDATE);   
  12.                     mHandler.sendMessage(msg);   
  13.                 }   
  14.          }.start();   
  15.     }  

五、AsyncTask与handler

 

         AsyncTask实际上就是一个线程池，AsyncTask在代码上比handler要轻量级别，而实际上要比handler更耗资源，因为AsyncTask底层是一个线程池！而Handler仅仅就是发送了一个消息队列，连线程都没有开。
但是，如果异步任务的数据特别庞大，AsyncTask这种线程池结构的优势就体现出来了。

         android的ui线程操作并不是安全的，并且和用户直接进行界面交互的操作都必须在ui线程中进行才可以。这种模式叫做单线程模式。

我们在单线程模式下编程一定要注意：不要阻塞ui线程、确保只在ui线程中访问ui组件

当我们要执行一个复杂耗时的算法并且最终要将计算结果反映到ui上时，我们会发现，我们根本没办法同时保证上面的两点要求；我们肯定会想到开启一个新的线程，让这个复杂耗时的任务到后台去执行，但是执行完毕了呢？我们发现，我们无法再与ui进行交互了。

为了解决这种情况，android为我们提供了很多办法。

1）handler和message机制：通过显示的抛出、捕获消息与ui进行交互；

2）Activity.runOnUiThread(Runnable)：如果当前线程为ui线程，则立即执行；否则将参数中的线程操作放入到ui线程的事件队列中，等待执行。

3）View.post(Runnable)：将操作放入到message队列中，如果放入成功，该操作将会在ui线程中执行，并返回true，否则返回false

4）View.postDelayed(Runnable, long)跟第三条基本一样，只不过添加了一个延迟时间。

5）android1.5以后为我们提供了一个工具类来搞定这个问题AsyncTask.

AsyncTask是抽象类，定义了三种泛型类型 Params，Progress，Result。

Params ：启动任务执行的输入参数，比如HTTP请求的URL

Progress： 后台任务执行的百分比。

Result ：后台执行任务最终返回的结果，比如String

用程序调用，开发者需要做的就是实现这些方法。

1) 子类化AsyncTask

2) 实现AsyncTask中定义的下面一个或几个方法

onPreExecute()，该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。

doInBackground(Params…)，将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的后台计算工作。可以调用 publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。

onProgressUpdate(Progress…)，在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。

onPostExecute(Result)，在doInBackground 执行完成后，onPostExecute 方法将被UI thread调用，后台的计算结果将通过该方法传递到UI thread.

为了正确的使用AsyncTask类，以下是几条必须遵守的准则：

1) Task的实例必须在UI thread中创建

2) execute方法必须在UI thread中调用

3) 不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params…), onProgressUpdate(Progress…)这几个方法

4) 该task只能被执行一次，否则多次调用时将会出现异常

[java] view plaincopy
 
    1. <span style="font-size: 14px;">    package cn.com.chenzheng_java;   
    2.           
    3.     import android.os.AsyncTask;   
    4.     /** 
    5.      *  
    6.      * @author chenzheng_java 
    7.      * @description 异步任务AcyncTask示例 
    8.      *     
    9.      */   
    10.     public class MyAsyncTask extends AsyncTask<String, Integer, Object> {   
    11.           
    12.      /** 
    13.      * 该方法由ui线程进行调用，用户可以在这里尽情的访问ui组件。 
    14.      * 很多时候，我们会在这里显示一个进度条啥的，以示后台正在 
    15.      * 执行某项功能。 
    16.      */   
    17.      @Override   
    18.      protected void onPreExecute() {   
    19.      super.onPreExecute();   
    20.      }   
    21.           
    22.      /** 
    23.      * 该方法由后台进程进行调用，进行主要的耗时的那些计算。 
    24.      * 该方法在onPreExecute方法之后进行调用。当然在执行过程中 
    25.      * 我们可以每隔多少秒就调用一次publishProgress方法，更新 
    26.      * 进度信息 
    27.      */   
    28.      @Override   
    29.      protected Object doInBackground(String... params) {   
    30.      return null;   
    31.      }   
    32.           
    33.           
    34.      /** 
    35.      * doInBackground中调用了publishProgress之后，ui线程就会 
    36.      * 调用该方法。你可以在这里动态的改变进度条的进度，让用户知道 
    37.      * 当前的进度。 
    38.      */   
    39.      @Override   
    40.      protected void onProgressUpdate(Integer... values) {   
    41.      super.onProgressUpdate(values);   
    42.      }   
    43.           
    44.      /** 
    45.      * 当doInBackground执行完毕之后，由ui线程调用。可以在这里 
    46.      * 返回我们计算的最终结果给用户。 
    47.      */   
    48.      @Override   
    49.      protected void onPostExecute(Object result) {   
    50.      super.onPostExecute(result);   
    51.      }   
    52.     }   
    53. </span>  

Handle机制详解

标签：des   android   style   blog   http   java   os   使用   io   

原文地址：http://www.cnblogs.com/kevincode/p/3931675.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！