AsyncTask源码阅读

最新推荐文章于 2024-07-28 22:57:09 发布
最新推荐文章于 2024-07-28 22:57:09 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 学习记录 源码学习 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mouse12138/article/details/81061193
版权

AsyncTask使用

Android中的耗时操作需要放到子线程异步处理，除了使用Thread，Android提供了一个封装好的组件AsyncTask。
使用方法代码如下：
public class AsyncTaskActivity extends AppCompatActivity {

private TextView mProgress;
private ImageView mImage;
private MyDownloadAsyncTask myDownloadAsyncTask;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_async_task);
    initView();
}

public void download(View view) {
    myDownloadAsyncTask = new MyDownloadAsyncTask();
    myDownloadAsyncTask.execute("https://www.baidu.com/img/baidu_jgylogo3.gif");
}

public void cancel(View view) {
    myDownloadAsyncTask.cancel(true);
}

private void initView() {
    mProgress = (TextView) findViewById(R.id.progress);
    mImage = (ImageView) findViewById(R.id.image);
}

public class MyDownloadAsyncTask extends AsyncTask<String, Integer, Bitmap> {
    @Override
    protected void onPreExecute() {
        //doInBackground执行之前
        mProgress.setText("下载任务准备开始");
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        //doInBackground执行之后
        if (bitmap != null) {
            mImage.setImageBitmap(bitmap);
        }

    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        //doInBackground执行中
        mProgress.setText("任务进行中：" + values[0] + "%");
    }
    @Override
    protected Bitmap doInBackground(String... strings) {
        Log.e("MyDownloadAsyncTask", "ThreadName：" + Thread.currentThread().getName());
        try {
            URL url = new URL(strings[0]);
            HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
            // 使用 URL 连接进行输出
            httpURLConnection.setDoOutput(true);
            // 使用 URL 连接进行输入
            httpURLConnection.setDoInput(true);
            // 忽略缓存
            httpURLConnection.setUseCaches(false);
            // 设置URL请求方法
            httpURLConnection.setRequestMethod("GET");

            InputStream inputStream = httpURLConnection.getInputStream();
            int contentLength = httpURLConnection.getContentLength();

            ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
            byte[] buff = new byte[100];
            int length = 0;
            int sum = 0;
            while ((length = inputStream.read(buff)) > 0) {
                swapStream.write(buff, 0, length);
                sum += length;
                double percent = sum * 1.0f / contentLength * 100;
                publishProgress((int) percent);
            }
            byte[] bytes = swapStream.toByteArray();
            Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
            return bitmap;

        } catch (MalformedURLException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }

    }
}

}
三个泛型 Params, Progress, Result分别对应传入的参数类型，中间进度的类型，返回结果的类型。AsyncTask主要有doInBackground、onPreExecute、onPostExecute、onProgressUpdate四个个方法。
doInBackground：必须要重写，异步执行后台线程，要完成的耗时任务在这里处理，运行在子线程。
onPreExecute：执行doInBackground前被调用,进行耗时操作前的初始化或者准备工作，运行在主线程。
onProgressUpdate：doInBackground执行完成后调用，返回处理结果，更新UI等，运行在主线程。
onProgressUpdate：在doInBackground方法中调用publishProgress方法后调用更新耗时任务进度，运行在主线程。
上面代码中实现了自己的MyDownloadAsyncTask完成一个图片下载的简单Demo。三个泛型分别为String、Integer、Bitmap类型，对应传入参数图片地址、下载进度、和下载完成的图片。doInBackground方法中发送网络请求下载图片，调用publishProgress在onProgressUpdate中实现进度更新。然后在按钮点击事件中调用execute方法开始执行。除此之外，调用cancel可以取消任务。

源码阅读

AsyncTask一共不多七百多行代码，所以可以先看一下其中包含的方法和成员变量。

先来看下成员变量的具体有哪些：

/**
 * 日志Tag
 */
private static final String LOG_TAG = "AsyncTask";

/**
 * CPU核心数
 */
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
/**
 * 线程池核心线程数
 */
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
/**
 * 线程池最大线程数
 */
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
/**
 *  线程闲置超时时间
 */
private static final int KEEP_ALIVE_SECONDS = 30;

/**
 * 线程工厂
 */
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    /**
     *  保证原子性 支持原子指令Integer型
     */
    private final AtomicInteger mCount = new AtomicInteger(1);

    public Thread newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};
/**
 * LinkedBlockingQueue链表结构有序阻塞队列用来存取任务  容量为128
 */
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);

/**
 * 执行任务的线程池
 */
public static final Executor THREAD_POOL_EXECUTOR;
/**
 * 任务排队的线程池
 */
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

/**
 * 结果消息
 */
private static final int MESSAGE_POST_RESULT = 0x1;
/**
 * 进度消息
 */
private static final int MESSAGE_POST_PROGRESS = 0x2;

/**
 *  任务排队的线程池 SerialExecutor
 */
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
/**
 * UI线程主线程的Handler
 */
private static InternalHandler sHandler;

/**
 *  一个封装了带Params的Callable抽象类,用来执行任务
 */
private final WorkerRunnable<Params, Result> mWorker;
/**
 * 处理结果任务
 */
private final FutureTask<Result> mFuture;

/**
 * AsyncTask的状态
 */
private volatile Status mStatus = Status.PENDING;
/**
 * 当前任务是否被取消
 */
private final AtomicBoolean mCancelled = new AtomicBoolean();
/**
 * 当前任务是否被调用
 */
private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

接下来看AsyncTask的几个内部类：

/**
 * 存放任务结果
 * @param <Data>
 */
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;

    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}

/**
 * 主线程Handler
 */
private static class InternalHandler extends Handler {
    public InternalHandler(Looper looper) {
        super(looper);
    }

    @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;
        }
    }
}

/**
 * 由ArrayDeque队列构成的串行线程池
 */
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);
        }
    }
}

/**
 * 封装了带Params的Callable抽象类
 * @param <Params>
 * @param <Result>
 */
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}

/**
 * 状态枚举
 *
 */
public enum Status {
    /**
     * 未执行状态
     */
    PENDING,
    /**
     * 运行状态
     */
    RUNNING,
    /**
     * 运行完成状态
     */
    FINISHED,
}

搞清楚了有些啥，就来可以研究AsyncTask到底是怎么运行的了。从使用方法来看，是先自定义了一个AsyncTask并且new了一个实例，那么首先要走的就是构造方法。

 public AsyncTask(@Nullable Looper callbackLooper) {
    /**
     * 初始化mHandler
     */
    mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);
    /**
     * 初始化WorkerRunnable
     */
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Result result = null;
            try {
                //线程优先级设置后台线程
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //执行doInBackground返回result
                result = doInBackground(mParams);
                Binder.flushPendingCommands();
            } catch (Throwable tr) {
                //异常则取消
                mCancelled.set(true);
                throw tr;
            } finally {
                //调用postResult方法
                postResult(result);
            }
            return result;
        }
    };
    /**
     * 初始化FutureTask
     */
    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);
            }
        }
    };
}

构造方法中初始化了一个Handler，因为传入是空所以拿到的Handler是主线程的Handler，通过此Handler接收消息处理与主线程的交互。除此之外还初始化一个WorkerRunnable，这个抽象类之前看过知识继承了Callable接口，并且保存了一个我们传入的参数Params。在call方法中调用了doInBackground方法并返回result。如果catch到异常就会取消任务，最终都会执行postResult方法将运行结果发送出去。

postResult方法的代码：

 /**
 * 发送提交结果的消息
 * @param result
 * @return
 */
private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

发送message给handler处理，msg.what为MESSAGE_POST_RESULT,msg.obj传一个AsyncTaskResult 。

在回到构造函数，看到接着new了一个FutureTask对象，并且将worker传入。

可以看到FutureTask继承RunnableFuture接口，而RunnableFuture又继承了Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。在done方法里get获取到mWorker的call方法的返回值后会调用postResultIfNotInvoked方法。

private void postResultIfNotInvoked(Result result) {
    final boolean wasTaskInvoked = mTaskInvoked.get();
    if (!wasTaskInvoked) {
        postResult(result);
    }
}

在postResultIfNotInvoked方法里根据mTaskInvoked状态执行postResult方法。至此构造函数结束。

除了构造方法，静态代码块也会在类加载时运行，接着看静态代码块里的内容：

/**
 * 静态代码块中初始化线程池
 */
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的execute方法，来看execute方法。

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

execute方法调用了executeOnExecutor方法传入了参数和sDefaultExecutor线程池。sDefaultExecutor是一个串行任务队列线程池。

/**
 * 任务排队的线程池
 */
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

/**
 *  任务排队的线程池 SerialExecutor
 */
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

/**
 * 由ArrayDeque队列构成的串行线程池
 */
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);
        }
    }
}

sDefaultExecutor由一个数组结构的双向队列构成，从队列中取出任务后放入THREAD_POOL_EXECUTOR执行。

继续看executeOnExecutor方法：

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();

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

    return this;
}

首先是根据mStatus状态，Running或者Finish则会抛出异常。所以一个AsyncTask只能调用execute方法一次。若状态正确则把Status修改为Running 。然后调用onPreExecute()方法，并且将传入的params传给mWorker中，然后调用线程池的execute方法传入mFuture。任务执完成后发送消息。Handler接收到根据message.what的类型分别调用finish方法和onProgressUpdate方法。调用finish方法再会根据是否取消状态来调用onPostExecute和onCancelled方法，至此工作流程结束。

  /**
   * 主线程Handler
   */
private static class InternalHandler extends Handler {
    public InternalHandler(Looper looper) {
        super(looper);
    }

    @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;
        }
    }
}

 private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

AsyncTask的工作流程图：

AsyncTask的结构图：

AsyncTask的几个注意点

1、AsyncTask 对象必须在主线程创建。

sHandler是静态的对象，为了能够将环境切换到主线程，就必须要求这个对象必须在主线程创建，由于静态成员变量会在类加载时候进行初始化，也就变相要求AsyncTask的类必须在主线程中加在。

2、Android3.0之前AsyncTask是并行执行任务，3.0之后为串行执行。

从3.0之后的源码，可知SerialExecutor是一个串行的任务线程池，所以3.0之后的AsyncTask是串行执行任务。
3.0之前，源码中并没有SerialExecutor这个线程池，只有一个任务执行线程池，所以是并发的。3.0之后想要并行执行任务，只需要调用executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,params)设置即可。

3、内存泄漏

在Activity中使用AsyncTask，AsyncTask持有Activity的引用，如果在网络请求没有结束，但是Activity已经被关闭的情况下，Actuvity的引用的不到释放，就会造成内存泄漏。

解决方法:
1、将AsyncTask设置为static，设置成静态对象后，在Activity类初始化的时候会初始化，会占用一定内存，但是会和Activity同生命周期，Activity销毁时AsyncTask也会被销毁。
2、使用弱引用WeakReference，这样gc运行时就会回收，避免内存泄漏。
AsyncTask不是有cancel方法吗？在activity生命周期结束前调用cancel方法不就行了吗？为什么不行呢？
原因：
  public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

futreTask的cancel方法

  public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
          U.compareAndSwapInt(this, STATE, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
                U.putOrderedInt(this, STATE, INTERRUPTED);
            }
        }
    } finally {
        finishCompletion();
    }
    return true;
}
查看cancel的源码可知AsyncTask的cancel调用了FutrueTask的cancel，归根结底是调用了线程的interrupt()方法，而interrupt()方法不会真正的中断一个正在运行的线程，而是发出中断请求。然后由线程在一个合适的时刻中断自己。
参考资料：Android进阶之光、Android开发艺术探索
一个写代码的胖子
关注
专栏目录
Android AsyncTask源代码浅析
菜鸟博客
10-23 1979
AsyncTask源代码分析
Android AsyncTask 源码解析
810364804
08-18 271
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/38614699，本文出自：【张鸿洋的博客】 1、概述 相信大家对AsyncTask都不陌生，对于执行耗时任务，然后更新UI是一把利器，当然也是替代Thread + Handler 的一种方式。如果你对Handler机制还不了解，请看：Android 异步消息处理机制 让你深入理解 ...
详细讲解AsyncTask使用说明(值得收藏)
最新发布
chinaherolts2008的博客
07-28 115
AsyncTask允许我们的执行一个异步的任务在后台。这里判断AsyncTask是否已经取消，如果不取消就执行我们的onPostExecute()，最后将状态设置为FINISHED，整一个AsyncTask的方法都执行完了，我们只需要继承AsyncTask实现其中的方法就可以按分析的顺序往下执行了。result.mTask也就是AsyncTask，最后调用result.mTask.finish(result.mData[0])，即AsyncTask的finish()方法，我们跟踪到finish()方法。
AsyncTask源码
皮卡丘的博客
03-06 139
摘抄自：https://blog.csdn.net/singwhatiwanna/article/details/17596225 public abstract class AsyncTask&lt;Params, Progress, Result&gt; { private static final String LOG_TAG = "AsyncTask"; //获取当前的cpu...
AsyncTask实现代码原理
linghu_java的专栏
01-30 5996
Android从1.5开始引入了AsyncTask这个类，可以帮助我们解决线程和界面刷新问题，主要是对Thread+Handler这样的封装，但在设计模式和代码维护方面都有不错的表现。早在2008年时Google推出了一个示例应用叫PhotoStream来演示UI在多线程网络慢速I/O下的刷新问题，里面的线程构造使用的正是AsyncTask的雏形，由于内部使用Java 1.5的并发库比普通初级An
Android应用AsyncTask处理机制详解及源码分析
热门推荐
工匠若水
05-28 1万+
【工匠若水 http://blog.csdn.net/yanbober 转载烦请注明出处，尊重分享成果】1 背景Android异步处理机制一直都是Android的一个核心，也是应用工程师面试的一个知识点。前面我们分析了Handler异步机制原理（不了解的可以阅读我的《Android异步消息处理机制详解及源码分析》文章），这里继续分析Android的另一个异步机制AsyncTask的原理。当使用线程
Android AsyncTask源码分析
01-20
Android的AsyncTask是一个轻量级的异步任务框架，它被设计用来简化在主线程与后台线程之间进行数据交互的复杂性。由于Android的UI更新必须在主线程中进行，AsyncTask通过内部封装Handler和线程池，使得开发者可以在...
AsyncTask 源码解析
09-03
AsyncTask 是 Android 开发中常用的一个轻量级...在阅读提供的 "AsyncTask 源码解析@www.java1234.com.pdf" 文件时，应重点关注这些关键点，结合源码理解其工作原理，这对于提升 Android 应用性能和用户体验至关重要。
AsyncTask 的源码分析
qq_40014062的博客
04-17 237
AsyncTask 的源码分析 基础知识学习 ThreadPoolExecutor分析 关键参数分析 corePoolSize：最大的核心线程数，默认情况下，核心线程会一直存活。 maximumPoolSize：线程池中最大线程数量(核心和非核心线程总数)，如果活动线程数等于最大值是，后续的新任务还会被阻塞。 keepAliveTime：非核心线程的保留时间，超时会被回收。 unit：keepA...
AsyncTask 源码分析
刘胡来
07-07 363
AsyncTask源码解析 一、先来看一个例子：使用异步任务类实现（1，100）的求和。 private class TestAsyncTask extends AsyncTask&amp;lt;Integer,Integer,Integer&amp;gt;{ private int sum = 0; private int i = 0; @Overr...
AsyncTask源码分析
fuyinghaha的专栏
05-08 119
首先看AsyncTask的execute 为啥一个任务实例只能执行一次，如果执行第二次将会抛出异常 看下面的代码，一共有三种状态PENDING（尚未执行），RUNNING（执行中），FINISHED（已经执行完），只有是未执行则开始执行，否则是执行中或是已经执行完则抛异常． if (mStatus != Status.PENDING) { swit...
AsyncTask源码解析
chenzujie的博客
07-04 2584
上周在做项目过程中，发现使用了较多的Thread+Handler和AsyncTask的方式，这周抽空看了下AsyncTask 源码（扣除各种注释，源码就剩三四百行非常简短），了解了AsyncTask的整个运行机制，现在分享如下： 总体上来说AsyncTask 1、使用Executor执行Callable和FutureTask的线程方法运行异步代码，并利用FutueTask的get()方法获取
AsyncTask - 源码篇
kid1421lzj的博客
04-08 207
概述 AsyncTask是一个轻量级选手，适合处理轻量级的后台任务。处理过程中还可以把处理的进度反馈到主线程中，方便我们更新UI，不需要我们去操作 handler，在早期 Android 版本中是十分方便的工具。今天我们来一起来阅读一下源码吧 ~ 1. 类注释 * <p>AsyncTask enables proper and easy use of the UI thread. T...
Async源码分析
飒然的天空
08-22 175
原文链接：http://www.srhang.me/blog/2014/08/22/node-async-analysis/   最近在使用到node js的async库的时候，对其waterfall的实现感觉很奇妙，于是看了一下源码： async.waterfall = function (tasks, callback) { callback = callback ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值