android异步消息机制 从源码层面解析(2)

AsyncTask

什么是AsyncTask

AsyncTask是一个轻量级的异步任务类,它可以在线程池中执行后台任务,然后把执行的进度和结果传递给主线程并在主线程中更新UI。

AsyncTask这个类的声明如下

public abstract class AsyncTask<Params, Progress, Result> 

它提供了Params, Progress和 Result三个泛型参数,在下面会仔细分析这三个泛型参数的具体含义。

AsyncTask提供了四个核心方法

onPreExecute()

此方法在主线程中执行,在异步任务执行之前,此方法会被调用,一般用于一些准备工作,例如下载进度条的初始化。

doInBackground(Params… params)

此方法在子线程中执行,用于执行异步任务,注意这里的params就是AsyncTask的第一个参数类型。在此方法中可以通过调用publicProgress方法来更新任务进度,publicProgress会调用onProgressUpdate方法。

onProgressUpdate(Progress… values)

此方法在主线程中执行,values的类型就是AsyncTask传入的第二个参数类型,当后台任务的执行进度发生变化时此方法执行。

onPostExecute(Result result)

此方法在主线程中执行,在doInBackground方法执行完成以后此方法会被调用,其中result的类型就是AsyncTask传入的第三个参数类型,它的值就是doInBackground方法的返回值。

接着还是看一下AsyncTask最常见的用法,该事例就是下载一张图片到手机内存的cache目录下,下载开始时会弹出进度框,在下载过程中显示下载的进度,下载完成后关闭进度框,如成功则出现下载成功的Toast,失败则弹出失败的Toast。

class MyAsyncTask extends AsyncTask<Void,Integer,Boolean> {
 @Override
 protected void onPreExecute() {
 progressDialog = new ProgressDialog(MainActivity.this);
 progressDialog.setTitle("下载进度");
 progressDialog.setMax(100);
 progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
 progressDialog.setCancelable(true);
 progressDialog.show();
 }

  @Override
protected Boolean doInBackground(Void... params) {
 HttpURLConnection conn = null;
 try {
  conn = (HttpURLConnection) params[0].openConnection();
  conn.setRequestMethod("GET");
  conn.setConnectTimeout(5000);
  conn.setReadTimeout(5000);
  final int contentLength;
  if (conn.getResponseCode() == 200) {
  contentLength = conn.getContentLength();
  File file = new File(getCacheDir(),"hh.jpg");
  InputStream is= null;
  FileOutputStream fos= new FileOutputStream(file);
  is = conn.getInputStream();
  int len = 0;
  long totalSize = 0;
  byte[] bytes = new byte[102];
  while ((len = is.read(bytes))!=-1) {
   fos.write(bytes,0,len);
   totalSize += len*100;
   int progress = (int) (totalSize/contentLength);
   publishProgress(progress);
  }
 }

 } catch (IOException e) {
  e.printStackTrace();
 }
  return true;
}

  @Override
 protected void onProgressUpdate(Integer... values) {
  progressDialog.setProgress(values[0]);

  }

  @Override
 protected void onPostExecute(Boolean aBoolean) {
  progressDialog.dismiss();
  if (result) {
  Toast.makeText(context, "下载成功", Toast.LENGTH_SHORT).show();
  } else {
  Toast.makeText(context, "下载失败", Toast.LENGTH_SHORT).show();
   }
  }
 }

这个类主要用于模拟文件的下载过程,它输入参数为图片url地址,后台的进程参数为Integer类型,后台任务的返回结果为bollean类型。当要执行上述下载任务时,可以通过如下方式来完成:

//在主线程中调用,执行后就会执行doInBackground等方法
URL url = new URL("http://192.168.43.21:8080/ditu.jpg");
   new MyAsyncTask().execute(url);

源码分析

首先我们从AsyncTask的构造方法着手。

 /**
  * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
  */
 public AsyncTask() {
  mWorker = new WorkerRunnable<Params, Result>() {
   public Result call() throws Exception {
    mTaskInvoked.set(true);

    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    //noinspection unchecked
    Result result = doInBackground(mParams);
    Binder.flushPendingCommands();
    return postResult(result);
   }
  };

  mFuture = new FutureTask<Result>(mWorker) {
   @Override
   protected void done() {
    try {
     postResultIfNotInvoked(get());
    } catch (InterruptedException e) {
     android.util.Log.w(LOG_TAG, e);
    } catch (ExecutionException e) {
     throw new RuntimeException("An error occurred while executing doInBackground()",
       e.getCause());
    } catch (CancellationException e) {
     postResultIfNotInvoked(null);
    }
   }
  };
 }

1.如注释所说,这个构造方法必须在UI线程中调用。
2.构造函数主要是创建了两个实例。一个是WorkerRunnable,它是一个Callback对象。另一个是FutureTask,它的参数就是前面创建的WorkerRunnable对象。

接下来我们再看AsyncTask的execute()方法,这个方法是整个异步任务的入口。

@MainThread
 public final AsyncTask<Params, Progress, Result> execute(Params... params) {
  return executeOnExecutor(sDefaultExecutor, params);
 }
  @MainThread
 public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
   Params... params) {
  if (mStatus != Status.PENDING) {
   switch (mStatus) {
    case RUNNING:
     throw new IllegalStateException("Cannot execute task:"
       + " the task is already running.");
    case FINISHED:
     throw new IllegalStateException("Cannot execute task:"
       + " the task has already been executed "
       + "(a task can be executed only once)");
   }
  }

  mStatus = Status.RUNNING;
  //onPreExecute()调用
  onPreExecute();
  //这里的参数由AsyncTask构造函数传进来的第一个参数,传入到doInBackground(mParams)中
  mWorker.mParams = params;
  //*******************
  exec.execute(mFuture);

  return this;
 }

我们看到了onPreExecute()被调用了,证明它确实是在执行后台任务之前调用了,且是在主线程调用。此时我们执行了实例代码中的进度条显示框的显示操作,此时的界面如下

,在此方法中还进行了一个操作exec.execute(mFuture),首先我们得知道exec到底是什么?在下面源码中我们就能得到答案。

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

根据如上代码以及executeOnExecutor传进来的参数,我们看到这里的exec其实就是SerialExecutor,那我们就来看看SerialExecutor的execute方法

public synchronized void execute(final Runnable r) {
   mTasks.offer(new Runnable() {
    public void run() {
     try {
      r.run();
     } finally {
      scheduleNext();
     }
    }
   });
   if (mActive == null) {
    scheduleNext();
   }
  }

我们看到在子线程里执行了r.run(),根据execute()方法传入的参数可知这里的r就是最开始在构造方法中创建的FutureTask,当然接下来就该看看FutureTask的run()方法了

public void run() {
  if (state != NEW ||
   !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
   return;
  try {
   Callable<V> c = callable;
   if (c != null && state == NEW) {
    V result;
    boolean ran;
    try {
    //****************************
     result = c.call();
     ran = true;
    } catch (Throwable ex) {
     result = null;
     ran = false;
     setException(ex);
    }
    if (ran)
     set(result);
   }
  } finally {
   // runner must be non-null until state is settled to
   // prevent concurrent calls to run()
   runner = null;
   // state must be re-read after nulling runner to prevent
   // leaked interrupts
   int s = state;
   if (s >= INTERRUPTING)
    handlePossibleCancellationInterrupt(s);
  }
 }

这里有一个result = c.call()方法,而这里的c就是Callable c = callable;里传进来的callable,而callable就是我们最开始在AsyncTask构造方法里传进来的WorkerRunnable,所以接着就该看看WorkerRunnable的call()方法,这个call()方法主要是调用了doInBackground(mParams)和postResult(result)方法

mWorker = new WorkerRunnable<Params, Result>() {
 public Result call() throws Exception {
  mTaskInvoked.set(true);
       Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    //noinspection unchecked
  //*********************************
  Result result = doInBackground(mParams);
  Binder.flushPendingCommands();
  return postResult(result);
 }

1.在这里我们看到doInBackground(mParams)方法的调用,并且此时仍然是在子线程中,所以在这里可以执行耗时操作。在上面的案例中doInBackground方法里的代码将会执行,当执行到publishProgress()方法时,会不断将进度信息传递给onProgressUpdate()方法(后面的分析中会解释为什么publishProgress()的执行能导致onProgressUpdate()方法的调用),让此方法执行更新UI.执行到这里时,案例中的下载界面如下,此时进度正好走到50%:

2.方法的最后执行了postResult(result)方法,这里面的result参数就是我们doInBackground(mParams)的返回值,这个方法的主要作用就是创建一个InternalHandler实例并发送what=MESSAGE_POST_RESULT的消息,我们接着看这个方法的源码

private Result postResult(Result result) {
  @SuppressWarnings("unchecked")
  Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
    new AsyncTaskResult<Result>(this, result));
  message.sendToTarget();
  return result;
 }
 //message方法的sendToTarget(),最终还是handler发送信息个消息队列
 public void sendToTarget() {
  target.sendMessage(this);
 }

熟悉handler的朋友知道,target.sendMessage(this)方法就是将消息发送给了消息队列,而这个携带的消息就是message本身,message当中携带有MESSAGE_POST_RESULT和new AsyncTaskResult(this, result))对象,而这个对象由getHandler发送,最后也会由它来handleMessage()(对这个消息进行处理),所以我们必须找到这个handler

private static Handler getHandler() {
  synchronized (AsyncTask.class) {
   if (sHandler == null) {
   //在这里创建了名为sHandler的InternalHandler实例
    sHandler = new InternalHandler();
   }
   return sHandler;
  }
 }

根据上面getHandler()方法可知这个handler对象就是InternalHandler,那接下来的任务就是分析InternalHandler的handlerMessage()方法,这个方法的作用就是根据postResult(Result result)方法中的sHandler发送的不同消息进行判断来执行不同的逻辑。

@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
 AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
 switch (msg.what) {
  case MESSAGE_POST_RESULT:
  // There is only one result
   result.mTask.finish(result.mData[0]);
     break;
  case MESSAGE_POST_PROGRESS:
   result.mTask.onProgressUpdate(result.mData);
     break;
   }
}
//result.mTask.finish(result.mData[0])方法如下
 private void finish(Result result) {
  if (isCancelled()) {
   onCancelled(result);
  } else {
   onPostExecute(result);
  }
  mStatus = Status.FINISHED;
 }
//result.mTask.onProgressUpdate(result.mData)
 @MainThread
 protected void onProgressUpdate(Progress... values) {
 }

由上面源码可知,它根据msg携带的不同what信息进行不同的消息处理,当what = MESSAGE_POST_RESULT时,最终会执行onCancelled(result)或者onPostExecute(result),这两个方法执行时全部都是在主线程,而MESSAGE_POST_RESULT就是刚刚获取信息时传入的。执行在这里时我们下载事例的代码就走到了onPostExecute(result),我们进行了进度框的隐藏操作,执行的界面如下:

但是MESSAGE_POST_PROGRESS参数又是哪里传来的,没错,就是publishProgress(Progress… values)

@WorkerThread
protected final void publishProgress(Progress... values) {
 if (!isCancelled()) {
    getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
     new AsyncTaskResult<Progress>(this, values)).sendToTarget();
  }
 }

这里传入MESSAGE_POST_PROGRESS,并且此方法在WorkerThread中调用。这样onProgressUpdate(Progress… values)方法就能顺利执行。整个流程结束

总结

1.AsyncTask的对象只能在主线程中创建
2.execute()方法只能在UI线程执行
3.不要在程序中直接调用onPreExecute,onPostExecute,doInBackground,onProgressUpdate方法
4.一个AsyncTask对象只能执行一次execute方法,否者会报运行时错误,在执行execute方法时,会调用到如下代码证明这个结论

if (mStatus != Status.PENDING) {
 switch (mStatus) {
  case RUNNING:
   throw new IllegalStateException("Cannot execute task:"+ " the task is already running.");
  case FINISHED:
   throw new IllegalStateException("Cannot execute task:"+ " the task has already been executed "
 + "(a task can be executed only once)");
   }
  }

5.在Android1.6之前,AsyncTask是串行执行任务,在1.6以后,改为在线程池里并行处理任务,在3.0以后,又改为在线程池里串行执行任务。

在AsyncTask中有两个线程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一个handler(InternalHandler).
其中SerialExecutor用于任务的排队。在上面代码中,我们已经看到,在AsyncTask.execute的执行过程中我们会调用它的execute方法

private static class SerialExecutor implements Executor {
  final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
  Runnable mActive;

  public synchronized void execute(final Runnable r) {
   mTasks.offer(new Runnable() {
    public void run() {
     try {
      r.run();
     } finally {
      scheduleNext();
     }
    }
   });
   if (mActive == null) {
    scheduleNext();
   }
  }

  protected synchronized void scheduleNext() {
   if ((mActive = mTasks.poll()) != null) {
    THREAD_POOL_EXECUTOR.execute(mActive);
   }
  }
 }

我们看到首先会将FutureTask对象插入到队列mTask中,如果这个时候没有正在执行的AsyncTask活动,就会调用scheduleNext();执行下一个任务,当一个任务执行完成后又会执行下一个,从这可以看出AsyncTask默认是串行执行的

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Android 消息机制以及handler的内存泄露

    Handler 每个初学Android开发的都绕不开Handler这个"坎",为什么说是个坎呢,首先这是Android架构的精髓之一,其次大部分人都是知其然却不知其所以然.今天看到Handler.post这个方法之后决定再去翻翻源代码梳理一下Handler的实现机制. 异步更新UI 先来一个必背口诀"主线程不做耗时操作,子线程不更新UI",这个规定应该是初学必知的,那要怎么来解决口诀里的问题呢,这时候Handler就出现在我们面前了(AsyncTask也行,不过本质

  • Android消息机制Handler的工作过程详解

    综述 在Android系统中,出于对性能优化的考虑,对于Android的UI操作并不是线程安全的.也就是说若是有多个线程来操作UI组件,就会有可能导致线程安全问题.所以在Android中规定只能在UI线程中对UI进行操作.这个UI线程是在应用第一次启动时开启的,也称之为主线程(Main Thread),该线程专门用来操作UI组件,在这个UI线程中我们不能进行耗时操作,否则就会出现ANR(Application Not Responding)现象.如果我们在子线程中去操作UI,那么程序就回给我们抛

  • Android 消息机制问题总结

    Android的消息机制几乎是面试必问的话题,当然也并不是因为面试,而去学习,更重要的是它在Android的开发中是必不可少的,占着举足轻重的地位,所以弄懂它是很有必要的.下面就来说说最基本的东西. Looper 作用: 关联起Thread 循环取出消息 1.Looper是否可以直接实例化? Looper构造方法是私有的,其中做了两件事 创建一个MessageQueue 得到与之对应的Thread private Looper(boolean quitAllowed) { mQueue = ne

  • 深入浅析Android消息机制

    在Android中,线程内部或者线程之间进行信息交互时经常会使用消息,这些基础的东西如果我们熟悉其内部的原理,将会使我们容易.更好地架构系统,避免一些低级的错误. 每一个Android应用在启动的时候都会创建一个线程,这个线程被称为主线程或者UI线程,Android应用的所有操作默认都会运行在这个线程中. 但是当我们想要进行数据请求,图片下载,或者其他耗时操作时,是不可能在这个UI线程做的,因为Android在3.0以后的版本已经禁止了这件事情,直接抛出一个异常.所以我们需要一个子线程来处理那些

  • Android编程中的消息机制实例详解

    本文实例讲述了Android编程中的消息机制.分享给大家供大家参考,具体如下: 在分析Android消息机制之前,我们先来看一段代码: public class MainActivity extends Activity implements View.OnClickListener { private TextView stateText; private Button btn; @Override public void onCreate(Bundle savedInstanceState)

  • Android的消息机制

    一.简介 Android的消息机制主要是指Handler的运行机制,那么什么是Handler的运行机制那?通俗的来讲就是,使用Handler将子线程的Message放入主线程的Messagequeue中,在主线程使用. 二.学习内容 学习Android的消息机制,我们需要先了解如下内容. 消息的表示:Message 消息队列:MessageQueue 消息循环,用于循环取出消息进行处理:Looper 消息处理,消息循环从消息队列中取出消息后要对消息进行处理:Handler 平常我们接触的大多是H

  • Android 消息机制详解及实例代码

    Android 消息机制 1.概述 Android应用启动时,会默认有一个主线程(UI线程),在这个线程中会关联一个消息队列(MessageQueue),所有的操作都会被封装成消息队列然后交给主线程处理.为了保证主线程不会退出,会将消息队列的操作放在一个死循环中,程序就相当于一直执行死循环,每循环一次,从其内部的消息队列中取出一个消息,然后回调相应的消息处理函数(handlerMessage),执行完成一个消息后则继续循环,若消息队列为空,线程则会阻塞等待.因此不会退出.如下图所示: Handl

  • Android异步消息机制详解

    Android中的异步消息机制分为四个部分:Message.Handler.MessageQueue和Looper. 其中,Message是线程之间传递的消息,其what.arg1.arg2字段可以携带整型数据,obj字段可以携带一个Object对象. Handler是处理者,主要用于发送消息和处理消息.发送消息的方法是sendMessage:处理消息的方法是handleMessage(),Message字段携带的信息在该方法中用作判别. MessageQueue是消息队列,存放所有Handle

  • android利用消息机制获取网络图片

    在前面都写到用AsyncTask来获取网络中的图片.其实利用消息机制也能获取网络中的图片,而且本人感觉用消息机制还是挺简单的. 消息机制的图解: 下面就用看代码来理解上面的图片. 布局:activity_main.xml <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" an

  • android异步消息机制 源码层面彻底解析(1)

    Handler.Message.Loopler.MessageQueen 首先看一下我们平常使用Handler的一个最常见用法. Handler handler =new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); //这里进行一些UI操作等处理 } new Thread(new Runnable() { @Override public void run() {

  • Android6.0 消息机制原理解析

    消息都是存放在一个消息队列中去,而消息循环线程就是围绕这个消息队列进入一个无限循环的,直到线程退出.如果队列中有消息,消息循环线程就会把它取出来,并分发给相应的Handler进行处理:如果队列中没有消息,消息循环线程就会进入空闲等待状态,等待下一个消息的到来.在编写Android应用程序时,当程序执行的任务比较繁重时,为了不阻塞UI主线程而导致ANR的发生,我们通常的做法的创建一个子线程来完成特定的任务.在创建子线程时,有两种选择,一种通过创建Thread对象来创建一个无消息循环的子线程:还有一

  • 深入剖析Android消息机制原理

    在Android中,线程内部或者线程之间进行信息交互时经常会使用消息,这些基础的东西如果我们熟悉其内部的原理,将会使我们容易.更好地架构系统,避免一些低级的错误.在学习Android中消息机制之前,我们先了解与消息有关的几个类: 1.Message 消息对象,顾名思义就是记录消息信息的类.这个类有几个比较重要的字段: a.arg1和arg2:我们可以使用两个字段用来存放我们需要传递的整型值,在Service中,我们可以用来存放Service的ID. b.obj:该字段是Object类型,我们可以

  • Android编程之消息机制实例分析

    本文实例讲述了Android编程之消息机制.分享给大家供大家参考,具体如下: 一.角色描述 1.Looper: 一个线程可以产生一个Looper对象,由它来管理此线程里的Message Queue(消息队列). 2.Handler: 你可以构造Handler对象来与Looper沟通,以便push新消息到Message Queue里:或者接收Looper(从Message Queue取出)所送来的消息. 3. Message Queue(消息队列):用来存放线程放入的消息. 4.线程:UI thr

  • android线程消息机制之Handler详解

    android线程消息机制主要由Handler,Looper,Message和MessageQuene四个部分组成.平常在开发中,我们常用来在子线程中通知主线程来更新,其实整个安卓生命周期的驱动都是通过Handler(ActivityThread.H)来实现的. 首先我们先介绍这四个类的作用: Handler:消息的发送者.负责将Message消息发送到MessageQueue中.以及通过Runnable,Callback或者handleMessage()来实现消息的回调处理 Looper:是消

  • 代码分析Android消息机制

    我们知道在编程时许多操作(如更新UI)需要在主线程中完成,而且,耗时操作(如网络连接)需要放在子线程中,否则会引起ANR.所以我们常使用Handler来实现线程间的消息传递,这里讨论的也就是Handler的运行机制. Handler的运行主要由两个类来支撑:Looper与MessageQueue.熟悉开发的朋友都知道在子线程中默认是无法创建Handler的,这是因为子线程中不存在消息队列.当需要创建一个与子线程绑定的Handler时,标准代码如下: class LooperThread exte

随机推荐