Android源码分析—带你认识不一样的AsyncTask

最新推荐文章于 2024-06-15 02:57:41 发布
最新推荐文章于 2024-06-15 02:57:41 发布
阅读量590 收藏 1
点赞数
分类专栏： android Android 基础

之前一直用AsyncTask，还不知道AsyncTask这个有并行和串行两种模式，记录一下。

本文转自：http://blog.csdn.net/singwhatiwanna/article/details/17596225

前言

什么是AsyncTask，相信搞过android开发的朋友们都不陌生。AsyncTask内部封装了Thread和Handler，可以让我们在后台进行计算并且把计算的结果及时更新到UI上，而这些正是Thread+Handler所做的事情，没错，AsyncTask的作用就是简化Thread+Handler，让我们能够通过更少的代码来完成一样的功能，这里，我要说明的是：AsyncTask只是简化Thread+Handler而不是替代，实际上它也替代不了。同时，AsyncTask从最开始到现在已经经过了几次代码修改，任务的执行逻辑慢慢地发生了改变，并不是大家所想象的那样：AsyncTask是完全并行执行的就像多个线程一样，其实不是的，所以用AsyncTask的时候还是要注意，下面会一一说明。另外本文主要是分析AsyncTask的源代码以及使用时候的一些注意事项，如果你还不熟悉AsyncTask，请先阅读android之AsyncTask 来了解其基本用法。

这里先给出AsyncTask的一个例子：

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... urls) {
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }

     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }

使用AsyncTask的规则

  • AsyncTask的类必须在UI线程加载（从4.1开始系统会帮我们自动完成）
  • AsyncTask对象必须在UI线程创建
  • execute方法必须在UI线程调用
  • 不要在你的程序中去直接调用onPreExecute(), onPostExecute, doInBackground, onProgressUpdate方法
  • 一个AsyncTask对象只能执行一次，即只能调用一次execute方法，否则会报运行时异常
  • AsyncTask不是被设计为处理耗时操作的，耗时上限为几秒钟，如果要做长耗时操作，强烈建议你使用Executor，ThreadPoolExecutor以及FutureTask
  • 在1.6之前，AsyncTask是串行执行任务的，1.6的时候AsyncTask开始采用线程池里处理并行任务，但是从3.0开始，为了避免AsyncTask所带来的并发错误，AsyncTask又采用一个线程来串行执行任务

AsyncTask到底是串行还是并行？

给大家做一下实验，请看如下实验代码：代码很简单，就是点击按钮的时候同时执行5个AsyncTask，每个AsyncTask休眠3s，同时把每个AsyncTask执行结束的时间打印出来，这样我们就能观察出到底是串行执行还是并行执行。

    @Override
    public void onClick(View v) {
        if (v == mButton) {
            new MyAsyncTask("AsyncTask#1").execute("");
            new MyAsyncTask("AsyncTask#2").execute("");
            new MyAsyncTask("AsyncTask#3").execute("");
            new MyAsyncTask("AsyncTask#4").execute("");
            new MyAsyncTask("AsyncTask#5").execute("");
        }

    }

    private static class MyAsyncTask extends AsyncTask<String, Integer, String> {

        private String mName = "AsyncTask";

        public MyAsyncTask(String name) {
            super();
            mName = name;
        }

        @Override
        protected String doInBackground(String... params) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return mName;
        }

        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Log.e(TAG, result + "execute finish at " + df.format(new Date()));
        }
    }


 

我找了2个手机，系统分别是4.1.1和2.3.3，按照我前面的描述，AsyncTask在4.1.1应该是串行的，在2.3.3应该是并行的，到底是不是这样呢？请看Log

Android 4.1.1上执行：从下面Log可以看出，5个AsyncTask共耗时15s且时间间隔为3s，很显然是串行执行的


Android 2.3.3上执行：从下面Log可以看出，5个AsyncTask的结束时间是一样的，很显然是并行执行


结论：从上面的两个Log可以看出，我前面的描述是完全正确的。下面请看源码，让我们去了解下其中的原理。

源码分析

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.os;

import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";

	//获取当前的cpu核心数
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
	//线程池核心容量
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
	//线程池最大容量
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
	//过剩的空闲线程的存活时间
    private static final int KEEP_ALIVE = 1;
	//ThreadFactory 线程工厂，通过工厂方法newThread来获取新线程
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
		//原子整数，可以在超高并发下正常工作
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
	//静态阻塞式队列，用来存放待执行的任务，初始容量：128个
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    /**
     * 静态并发线程池，可以用来并行执行任务，尽管从3.0开始，AsyncTask默认是串行执行任务
	 * 但是我们仍然能构造出并行的AsyncTask
     */
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

    /**
     * 静态串行任务执行器，其内部实现了串行控制，
	 * 循环的取出一个个任务交给上述的并发线程池去执行
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
	//消息类型：发送结果
    private static final int MESSAGE_POST_RESULT = 0x1;
	//消息类型：更新进度
    private static final int MESSAGE_POST_PROGRESS = 0x2;
	/**静态Handler，用来发送上述两种通知，采用UI线程的Looper来处理消息
	 * 这就是为什么AsyncTask必须在UI线程调用，因为子线程
	 * 默认没有Looper无法创建下面的Handler，程序会直接Crash
	 */
    private static final InternalHandler sHandler = new InternalHandler();
	//默认任务执行器，被赋值为串行任务执行器，就是它，AsyncTask变成串行的了
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
	//如下两个变量我们先不要深究，不影响我们对整体逻辑的理解
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
	//任务的状态 默认为挂起，即等待执行，其类型标识为易变的（volatile）
    private volatile Status mStatus = Status.PENDING;
    //原子布尔型，支持高并发访问，标识任务是否被取消
    private final AtomicBoolean mCancelled = new AtomicBoolean();
	//原子布尔型，支持高并发访问，标识任务是否被执行过
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

	/*串行执行器的实现，我们要好好看看，它是怎么把并行转为串行的
	 *目前我们需要知道，asyncTask.execute(Params ...)实际上会调用
	 *SerialExecutor的execute方法，这一点后面再说明。也就是说：当你的asyncTask执行的时候，
	 *首先你的task会被加入到任务队列，然后排队，一个个执行
	 */
    private static class SerialExecutor implements Executor {
		//线性双向队列，用来存储所有的AsyncTask任务
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
		//当前正在执行的AsyncTask任务
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
			//将新的AsyncTask任务加入到双向队列中
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
						//执行AsyncTask任务
                        r.run();
                    } finally {
						//当前AsyncTask任务执行完毕后，进行下一轮执行，如果还有未执行任务的话
						//这一点很明显体现了AsyncTask是串行执行任务的，总是一个任务执行完毕才会执行下一个任务
                        scheduleNext();
                    }
                }
            });
			//如果当前没有任务在执行，直接进入执行逻辑
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
			//从任务队列中取出队列头部的任务，如果有就交给并发线程池去执行
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    /**
     * 任务的三种状态
     */
    public enum Status {
        /**
         * 任务等待执行
         */
        PENDING,
        /**
         * 任务正在执行
         */
        RUNNING,
        /**
         * 任务已经执行结束
         */
        FINISHED,
    }

    /** 隐藏API：在UI线程中调用，用来初始化Handler */
    public static void init() {
        sHandler.getLooper();
    }

    /** 隐藏API：为AsyncTask设置默认执行器 */
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

    /**
     * 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
                return postResult(doInBackground(mParams));
            }
        };

        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 occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };
    }

    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }
	//doInBackground执行完毕，发送消息
    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

    /**
     * 返回任务的状态
     */
    public final Status getStatus() {
        return mStatus;
    }

    /**
	 * 这个方法是我们必须要重写的，用来做后台计算
	 * 所在线程：后台线程
     */
    protected abstract Result doInBackground(Params... params);

    /**
	 * 在doInBackground之前调用，用来做初始化工作
	 * 所在线程：UI线程
     */
    protected void onPreExecute() {
    }

    /**
	 * 在doInBackground之后调用，用来接受后台计算结果更新UI
	 * 所在线程：UI线程
     */
    protected void onPostExecute(Result result) {
    }

    /**
     * Runs on the UI thread after {@link #publishProgress} is invoked.
     /**
	 * 在publishProgress之后调用，用来更新计算进度
	 * 所在线程：UI线程
     */
    protected void onProgressUpdate(Progress... values) {
    }

     /**
	 * cancel被调用并且doInBackground执行结束，会调用onCancelled，表示任务被取消
	 * 这个时候onPostExecute不会再被调用，二者是互斥的，分别表示任务取消和任务执行完成
	 * 所在线程：UI线程
     */
    @SuppressWarnings({"UnusedParameters"})
    protected void onCancelled(Result result) {
        onCancelled();
    }    
    
    protected void onCancelled() {
    }

    public final boolean isCancelled() {
        return mCancelled.get();
    }

    public final boolean cancel(boolean mayInterruptIfRunning) {
        mCancelled.set(true);
        return mFuture.cancel(mayInterruptIfRunning);
    }

    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
            ExecutionException, TimeoutException {
        return mFuture.get(timeout, unit);
    }

    /**
     * 这个方法如何执行和系统版本有关，在AsyncTask的使用规则里已经说明，如果你真的想使用并行AsyncTask，
	 * 也是可以的，只要稍作修改
	 * 必须在UI线程调用此方法
     */
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
		//串行执行
        return executeOnExecutor(sDefaultExecutor, params);
		//如果我们想并行执行，这样改就行了，当然这个方法我们没法改
		//return executeOnExecutor(THREAD_POOL_EXECUTOR, params);
    }

    /**
     * 通过这个方法我们可以自定义AsyncTask的执行方式，串行or并行，甚至可以采用自己的Executor
	 * 为了实现并行，我们可以在外部这么用AsyncTask：
	 * asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, Params... params);
	 * 必须在UI线程调用此方法
     */
    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();

        mWorker.mParams = params;
		//然后后台计算#doInBackground才真正开始
        exec.execute(mFuture);
		//接着会有#onProgressUpdate被调用，最后是#onPostExecute

        return this;
    }

    /**
     * 这是AsyncTask提供的一个静态方法，方便我们直接执行一个runnable
     */
    public static void execute(Runnable runnable) {
        sDefaultExecutor.execute(runnable);
    }

    /**
	 * 打印后台计算进度，onProgressUpdate会被调用
     */
    protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

	//任务结束的时候会进行判断，如果任务没有被取消，则onPostExecute会被调用
    private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

	//AsyncTask内部Handler，用来发送后台计算进度更新消息和计算完成消息
    private static class InternalHandler extends Handler {
        @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 static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;

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


让你的AsyncTask在3.0以上的系统中并行起来

通过上面的源码分析，我已经给出了在3.0以上系统中让AsyncTask并行执行的方法，现在，让我们来试一试，代码还是之前采用的测试代码，我们要稍作修改，调用AsyncTask的executeOnExecutor方法而不是execute，请看：

    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    @Override
    public void onClick(View v) {
        if (v == mButton) {
            new MyAsyncTask("AsyncTask#1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
            new MyAsyncTask("AsyncTask#2").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
            new MyAsyncTask("AsyncTask#3").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
            new MyAsyncTask("AsyncTask#4").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
            new MyAsyncTask("AsyncTask#5").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
        }

    }

    private static class MyAsyncTask extends AsyncTask<String, Integer, String> {

        private String mName = "AsyncTask";

        public MyAsyncTask(String name) {
            super();
            mName = name;
        }

        @Override
        protected String doInBackground(String... params) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return mName;
        }

        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Log.e(TAG, result + "execute finish at " + df.format(new Date()));
        }
    }


下面是系统为4.1.1手机打印出的Log：很显然，我们的目的达到了，成功的让AsyncTask在4.1.1的手机上并行起来了，很高兴吧！希望这篇文章对你有用。

k763925053
关注
专栏目录
Android游戏源码不一样的拼图游戏源码.zip
07-10
这篇文档将深入解析《Android游戏源码不一样的拼图游戏源码》这个项目，它是一个针对Android平台的独特拼图应用。该应用提供了与传统拼图游戏不同的交互方式，允许玩家直接交换不相邻的图片块，而不仅仅是相邻的。...
Android学习路线指南
热门推荐
singwhatiwanna
11-01 24万+
前言 看到一篇文章中提到“最近几年国内的初级Android程序员已经很多了，但是中高级的Android技术人才仍然稀缺“，这的确不假，从我在百度所进行的一些面试来看，找一个适合的高级Android工程师的确不容易，一般需要进行大量的面试才能挑选出一个比较满意的。为什么中高级Android程序员不多呢？这是一个问题，我不好回答，但是我想写一篇文章来描述下Android的学习路线，期望可以帮助更多的...
Android：一种按顺序串行执行任务的解决方案
ChatGPTer
01-29 9889
在app开发过程中很多时候会遇到这样一种需要串行执行的需求，比如直播间送礼物，可能短时间内送来了很多的礼物，app需要根据送来的礼物的顺序依次播放礼物的动画，也就是需要在上一个动画播放完成后，继续播放下一个动画。 解决这个问题的思路如下： 1, 使用队列串行的特性，用来存储进来的任务，这里使用到了非阻塞队列ArrayDeque; 2, 利用线程池执行具体的任务; 3, 通过线程池的回调接口，传递给...
java中asynctask_Android（java）学习笔记92：Android线程形态之 AsyncTask （异步任务）...
weixin_42514394的博客
02-26 196
曾建议使用AsyncTask而不是使用Thread，但是AsyncTask似乎又有它的限制，这就要根据具体的需求情况而选择合适的工具，下面是一些建议：改善你的设计，少用异步处理线程的开销是非常大的，同时异步处理也容易出错，难调试，难维护，所以改善你的设计，尽可能的少用异步。对于一般性的数据库查询，少量的I/O操作是没有必要启动线程的。与主线程有交互时用AsyncTask，否则就用ThreadAsy...
Android Http客户端源码.rar
07-04
在Android开发中，HTTP客户端是应用与服务器进行数据交互的重要组成部分。这个压缩包"Android Http...通过分析提供的源代码，你可以学习到具体的实现方式，加深对这些概念的理解，并可能发现优化网络请求的新方法。
Android应用源码安卓与PC的Socket通信项目C#版+Java版.zip
12-04
2. **AsyncTask或者Thread**：由于Android主线程不支持长时间运行的操作，如网络通信，因此需要在后台线程（如`AsyncTask`或自定义`Thread`）中执行Socket通信，以避免阻塞UI。 3. **BufferedReader和PrintWriter**...
Android源码设计模式解析与实战
08-28
《Android源码设计模式解析与实战》是由和红辉、关爱民两位作者共同编著的一本深入探讨Android系统源码中设计模式应用的书籍。这本书旨在帮助开发者理解并掌握如何在Android开发中有效地运用设计模式，提升代码质量...
android通讯录的开发完整版终极源码
12-09
通过分析这个项目的源码，开发者可以了解到如何将以上各个知识点融入到实际应用中，提升自己的Android开发技能。同时，这也是一个很好的案例研究，可以帮助开发者了解如何组织代码结构、管理资源以及实现功能模块。
Android 多线程
WSJ ' Blog
04-13 509
Android多线程技术
【Android面试八股文】AsyncTask中的任务是串行的还是并行的
最新发布
字节卷动
06-15 223
串行执行：默认情况下，AsyncTask使用，任务按顺序执行。并行执行：通过可以使任务并行执行。根据具体需求选择合适的执行方式。如果任务需要共享资源或不能同时执行，建议使用串行执行；如果任务彼此独立且希望更快完成，可以选择并行执行。
Android AsyncTasks并行执行
从零开始的教程世界
07-13 498
In this tutorial, we’ll be digging deep into AsyncTasks in android by discussing the different ways of executing it. We’ll see the different ways to handle configuration changes with Async Tasks too. ...
Android AsyncTask实现一个线程操作完成后启动另一个线程
windvally的专栏
07-09 1920
如何在一个线程完成操作后执行另一个线程？ 有时候我们需要等待一个线程执行完成后再执行下一个线程。 发现asynctask可以实现这个功能，可以在一个线程操作完成后执行下一个线程。   原理就不多说了，直接看代码：     public class AsyncTaskTest extends Activity { private Button button01; private I
AsyncTask使用须知
pipisky2006的专栏
01-26 8824
AsyncTask的实现原理就是封装了的线程池，具体见AsyncTask实现原理。 在1.5中初始引入的时候， AsyncTask 执行( AsyncTask.execute() )起来是顺序的，当同时执行多个 AsyncTask的时候，他们会按照顺序一个一个执行。前面一个执行完才会执行后面一个。这样当同时执行多个比较耗时的任务的时候 可能不是您期望的结果，具体情况就像是execute的
android asyctask原理,Android面试题 - AsyncTask
weixin_33055757的博客
05-29 133
一、原理AsyncTask 本质上是对handler和线程池对封装，在线程池中执行耗时任务，当任务完成或任务更新时，向主线程的Handler发送消息，在Handler中执行finish()、onProgressUpdate()等方法。二、并行还是串行执行从 1.5 引入的时候的确是串行的，在 1.6-2.3.2 的时候执行顺序更改为并行了，在 3.0 之后又改回了串行。2.1 并行执行并行执行任务...
AsyncTask 串行还是并行
lmj121212的专栏
01-06 2384
AsyncTask 串行还是并行明白串行还是并行非常重要，如果是串行，那么如果有多个task，那么后面的task必须要等前面的task任务执行完了才会被执行。要明白这个问题，那就先来几百个任务试一下 public void dotask(View view) { for (int i = 0; i < 300; i++) { new MyAsynctask().execut
AsyncTask(多任务串行/并行)简单分析
qq_33635618的博客
07-12 829
1. 多实例并行时,使用　asynchTask.execute()提交的任务是串行执行的. 下面分析原因: 以下是两个异步实例提交任务: private void asynchTaskTest() { //　异步任务１ TestAnsycTask testAnsycTask1 = new TestAnsycTask(); Log.e("T...
AsyncTask的工作原理
奋斗在坚持的路上
06-27 292
在1.6之前，AsyncTask是串行执行任务的，1.6的时候AsyncTask开始采用线程池里处理并行任务，但是从3.0开始，为了避免AsyncTask所带来的并发错误，AsyncTask又采用一个线程来串行执行任务。 具体执行流程，通过源码来分析： public AsyncTask() { mWorker = new WorkerRunnable&amp;lt;Params, Re...
Android AsyncTask详解：使用与源码分析
"Android AsyncTask使用及源码解析" Android平台提供了AsyncTask类，旨在简化在主线程之外执行耗时操作，并且能将结果安全地传递回主线程更新UI的任务。AsyncTask是一个轻量级的异步任务框架，它利用线程池来管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值