Android中AsyncTask详解

作者: Steven_SHH | 来源:发表于2020-03-02 02:28 被阅读0次

定义

AsyncTask是一个抽象类，在使用时需要继承该类，实现其抽象方法protected abstract Result doInBackground(Params... params)。其主要作用就是实现多线程以及异步通信。其实现也是用Thread+Handler来进行实现的。

AsyncTask类的定义:

public abstract class AsyncTask<Params, Progress, Result> {
}

三个泛型参数解释：

Params：开始异步任务执行时传入的参数类型，对应excute()中传递的参数
Progress：异步任务执行过程中，返回下载进度值的类型
Result：异步任务执行完成后，返回的结果类型，与doInBackground()的返回值类型保持一致

核心方法


// 作用：执行 线程任务前的操作
@Override
protected void onPreExecute() {
    // 根据需求复写
}


// 作用：接收输入参数,执行任务中的耗时操作,返回线程任务执行的结果
// 注：必须复写，从而自定义线程任务
@Override
protected Result doInBackground(Params... params) {

      ...// 自定义的线程任务

      // 可调用publishProgress()显示进度, 之后将执行onProgressUpdate()
      // 通过Handler发送消息进行更新进度
      publishProgress(count);
        
}


// 作用：在主线程显示线程任务执行的进度
@Override
protected void onProgressUpdate(Progress... values) {
     // 注：根据需求复写
}


// 作用：接收线程任务执行结果,将执行结果显示到UI组件
@Override
protected void onPostExecute(Result result) {

   ...// UI操作

}


// 作用：将异步任务设置为：取消状态
@Override
protected void onCancelled() {
  ...
}

只有doInBackground()运行在子线程中，其余都运行在主线程中。在onPreExecute()执行完后，会立即执行doInBackground()方法。

使用方法

创建类继承AsyncTask类，传入相应的泛型参数，实现doInBackground()方法。然后再创建该类的对象，使用对象.execute()进行执行。

public class MyAsyncTask extends AsyncTask<String, Integer, String> {

     @Override
     protected String doInBackground(String... params) {
        return ...;
     }
}

// 创建对象
MyAsyncTask myAsyncTask = new MyAsyncTask(String, Integer, String);
// 执行方法
myAsyncTask.execute(String);

源码分析

AsyncTask主要步骤就是创建该类对象，执行execute方法。所以可以主要就从这两条线去查看源码。

构造函数

public AsyncTask(@Nullable Looper callbackLooper) {
    // 创建一个Handler，创建的时候如果没有传入Looper对象，则创建的就是主线程的Handler
    mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
        ? getMainHandler()
        : new Handler(callbackLooper);

    // mWorker代表了AsyncTask要执行的任务，WorkerRunnable是对Callable接口的封装,而mWorker作为参数传递给了mFuture
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Result result = null;
            try {
                // 设置优先级
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
            
                // doInBackground()就是我们需要覆写的方法
                result = doInBackground(mParams);
                Binder.flushPendingCommands();
            } catch (Throwable tr) {
                mCancelled.set(true);
                throw tr;
            } finally {
                // 最终的结果通过该方法使用Handler发送消息出去
                postResult(result);
            }
            return 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);
            }
        }
    };
}

构造函数可以为空，则调用上述构造方法传入的Looper对象为空。也可以传入Handler对象，最终也是调用上述构造方法，传入该Handler的Looper对象。

构造方法中会调用我们覆写的doInBackground()方法，返回值通过postResult()方法进行消息发送。

private Result postResult(Result result) {
    // getHandler()就是获取构造函数创建的Handler
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

execute方法

@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

execute方法需要在主线程中调用，返回调用executeOnExecutor()方法的返回值。

@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    ... 省略部分源码
    mStatus = Status.RUNNING;
    // 该方法就是执行doInBackground()方法之前的所执行的方法，可以根据需求进行覆写。
    onPreExecute();

    mWorker.mParams = params;
    exec.execute(mFuture);

    return this;
}

可以看到executeOnExecutor()传入了一个sDefaultExecutor的参数。

// sDefaultExecutor是一个静态常量
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
// SERIAL_EXECUTOR 是一个Executor的实现类对象
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static class SerialExecutor implements Executor {
    // 定义了一个双端队列
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;

    public synchronized void execute(final Runnable r) {
        // 通过offer方法从队列尾部插入
        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);
        }
    }
}

每次调用execute，就创建一个Runnable匿名内部类对象，这个对象存入双端队列mTasks，在匿名内部类的run函数里面调用传入参数r.run()。然后通过一个scheduleNext函数把mTasks里面的所有对象通过THREAD_POOL_EXECUTOR.execute(mActive)执行一遍。SerialExecutor类会把所有的任务丢入一个容器，之后把容器里面的所有对象一个一个的排队（串行化）执行THREAD_POOL_EXECUTOR.execute(mActive);

// THREAD_POOL_EXECUTOR 也是一个静态常量，也就是一个ThreadPoolExecutor线程池对象
public static final Executor THREAD_POOL_EXECUTOR;

static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            sPoolWorkQueue, sThreadFactory);
    threadPoolExecutor.allowCoreThreadTimeOut(true);

    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

最终也就是通过线程池执行所有的线程任务。

总结

线程池的创建:
在创建了AsyncTask的时候，会默认创建两个线程池SerialExecutor和ThreadPoolExecutor，SerialExecutor负责将任务串行化，ThreadPoolExecutor是真正执行任务的地方，且无论有多少个AsyncTask实例，两个线程池都会只有一份。
任务的执行:
在execute中，会执行run方法，当执行完run方法后，会调用scheduleNext()不断的从双端队列中轮询，获取下一个任务并继续放到一个子线程中执行，直到异步任务执行完毕
消息的处理：
在执行完onPreExecute()方法之后，执行了doInBackground()方法，然后就不断的发送请求获取数据；在这个AsyncTask中维护了一个Handler，获取的数据是通过handler进行处理和发送的。在其handleMessage方法中，将消息传递给onProgressUpdate()进行进度的更新，也就可以将结果发送到主线程中，进行界面的更新了。
使用AsyncTask的注意点
每一个new出的AsyncTask只能执行一次execute()方法，多次运行将会报错，如需多次，需要新new一个AsyncTask。

优缺点

优点：AsyncTask是一个轻量级的异步任务处理类，轻量级体现在，使用方便、代码简洁上，而且整个异步任务的过程可以通过cancel()进行控制；

缺点：不适用于处理长时间的异步任务，一般这个异步任务的过程最好控制在几秒以内，如果是长时间的异步任务就需要考虑多线程的控制问题；当处理多个异步任务时，UI更新变得困难。

使用注意事项

AsyncTask不与任何组件绑定生命周期，在Activity 或 Fragment中使用 AsyncTask时，最好在Activity 或 Fragment的onDestory（）调用 cancel(boolean)；
若AsyncTask被声明为Activity的非静态内部类，当Activity需销毁时，会因AsyncTask保留对Activity的引用而导致Activity无法被回收，最终引起内存泄露，最好将AsyncTask声明为Activity的静态内部类

Android中AsyncTask详解

定义

核心方法

使用方法

源码分析

构造函数

execute方法

总结

优缺点

使用注意事项

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读