Android AsyncTask

关注

原创最新推荐文章于 2026-05-25 09:13:32 发布 185 阅读 AI 写同款· GEO 优化 ›

UE5在Ubuntu22.04.4下的高效开发环境配置指南本文详细介绍了在Ubuntu 22.04.4系统上配置UE5高效开发环境的完整指南，包括系统准备、显卡驱动安装、UE5引擎编译与配置、开发工具链设置以及性能优化技巧。通过逐步指导，帮助开发者快速搭建稳定的UE5开发环境，解决常见问题，提升开发效率。阅读详情

类的简介
示例
代码浅析
优缺点总结

AsyncTask 支持正确、方便使用UI线程。不必去操作线程或者Handler，就可以把线程任务的结果返回到UI线程中来。注意哦，这里并没有用高并发、异步等词汇。

抽象类AsyncTask

public abstract class AsyncTask<Params, Progress, Result> {
...
 	@WorkerThread
    protected abstract Result doInBackground(Params... params);
...

}

首先AsyncTask是一个抽象类，而且需要确定三个泛型

Params ：数据源，如URL，IO流等。
Progress：处理的进度，如任务完成百分比等。
Result：任务处理完成，需要返回的结果类型。如需要返回一个List等。

类中有个抽象方法，doInBackground，运行在后台线程中。根据这个方法我们可以看到和其它方法的一些关系。

我们继承一AsyncTask

  public class MyAsyncTask extends AsyncTask<List, Integer, String> {
        /**
         * 在doInBackground之前调用。运行在UI线程中
         * 一般做些初始化操作
         */
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        /**
         * 具体处理任务的方法，在子线程中运行
         *
         * @param list
         * @return 任务处理完的时候返回的结果
         */
        @Override
        protected String doInBackground(List... list) {
            int length = list.length;
            for (int i = 0; i < length; i++) {
                List list1 = list[i];
                list1.add("你好");
                //把当前进度转到onProgressUpdate，UI线程中
                publishProgress(list1.size());
            }

            return "完成喽";
        }

        /**
         * 调用publishProgress之后会调用此方法并。
         * 内部是利用Handler进行消息处理，实现回调，并传入参数
         * 运行在UI线程中
         *
         * @param values
         */
        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            int length = values.length;
            for (int i = 0; i < length; i++) {
                Log.i("task", "values:  " + values[i] + "   i:" + i);
            }
        }

        /**
         * 不调用cancel方法并且doInBackground执行完成会回调
         * 回调的完成也是通过handler，并传入参数
         *
         * @param s
         */
        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
        }

        /**
         * 调用cancel方法并且doInBackground执行完成会回调
         * 回调的完成也是通过handler，并传入参数
         *
         * @param s
         */
        @Override
        protected void onCancelled(String s) {
            super.onCancelled(s);
        }
    }


		//Activity中执行的话
		MyAsyncTask myAsyncTask = new MyAsyncTask();
        myAsyncTask.execute(new ArrayList());

方法注释的很清楚了。运行起来看log吧，或者可以配合一些控件看看，最适合的就是读写文件的操作，看进度条。而且它里面的调用线程切换基本都是通过handler。毕竟Android里面handler就是专门干这个的。

源码浅析。
先从执行处开始，看看他的execute方法

  	@MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    	//直接调用了一个需要Execute的参数的方法
        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();
        
        mWorker.mParams = params;
        exec.execute(mFuture);

        return this;
    }

之后，最终会调用传入的Execute的execute方法。
而这个Execute其实是一个内部类SerialExecutor

private static class SerialExecutor implements Executor {
		//内部一个Object数组，实现一个队列的效果
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
        	//入队一个Runnable，run方法跑的是之前传进去的WorkerRunnable的参数
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                    	//先执行当前run方法
                        r.run();
                    } finally {
                    	//再取出队列中的第一个
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
        	//取出队列的第一个Runnable
            if ((mActive = mTasks.poll()) != null) {
            	//AsyncTask内部的线程池，执行Runnable
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

我们把数据源交给AsyncTask，然后它通过execute方法最终调用了交给了添加到Runnable中交给线程池处理，但是从代码中可以看出，必须前面一个任务执行完成后，才能执行下一个任务。

既然他是线程切换，肯定少不了handler和runnable实现。这些都在一个构造方法中，看代码：

	/**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     *
     * @hide
     */
    public AsyncTask(@Nullable Looper callbackLooper) {
   		//创建一个handler，有looper就根据looper，没有就默认是UI线程。
        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);
                    //noinspection unchecked
                    //调用doInBackground,在线程池中调用
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                	//关闭
                    mCancelled.set(true);
                    throw tr;
                } finally {
                	正常结束
                    postResult(result);
                }
                return result;
            }
        };
		//FutureTask，实现了Runnable接口
        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);
                }
            }
        };
    }
//返回结果
private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
        //最终利用handler
            postResult(result);
        }
    }

//
 private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

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

当然，我们只能调用无参构造方法，另外两个都被/**@hide*/了线程池处理任务，handler负责线程间通信。

总结

优点：

AsyncTask 通过线程池和handler，帮我们封装好了子线程处理任务到UI线程的返回过程。
五个方法
onPreExecute：开启任务线程前执行。运行在UI线程
doInBackground：任务线程中执行，运行中任务线程。
publishProgress：在doInBackground调用，把任务进度传递到UI线程。如果被关闭的话不再回调onProgressUpdate。
onProgressUpdate：调用publishProgress，并且没有被关闭的情况下执行，运行在UI线程。
onPostExecute：没有调用cancel方法并且doInBackground执行完成会回调，运行在UI线程。
onCancelled：调用cancel方法并且doInBackground执行完成会回调，运行在UI线程。

publishProgress：

@WorkerThread
    protected final void publishProgress(Progress... values) {
    	//没有关闭发送MESSAGE_POST_PROGRESS
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

finish：

private void finish(Result result) {
        if (isCancelled()) {
        	//关闭后的回调
            onCancelled(result);
        } else {
        	//没有关闭的回调
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

可能你会有疑问，AsyncTask只能调用一次execute方法，那还要线程池干嘛呢？
其实这个只能调用一次execute，是针对AsyncTask对象的。我们可以多new一些对象。而线程池是静态的。

 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);
		//静态Executor持有线程池的引用
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

缺点
现在我们在doInBackground中添加如下代码

			 @Override
        protected String doInBackground(List... list) {
            StringBuffer stringBuffer = new StringBuffer();
            for (int i = 0; i < 5; i++) {
                String s = "i:  " + i + "  threadName:  " + Thread.currentThread().getName();
                stringBuffer.append(s + "\n");
                publishProgress(s);
            }

            return stringBuffer.toString();
        }

写一个5次循环，i++，打印i值和线程名字，并把字符串传递出去

  @Override
        protected void onProgressUpdate(String... values) {
            super.onProgressUpdate(values);
            int length = values.length;
            for (int i = 0; i < length; i++) {
                Log.i("task", values[i]);
            }

        }

onProgressUpdate打印接收到的内容，执行五个任务。看下结果，如图：
日志图片
不看不知道一看吓一跳，有木有。虽然创建了五个线程，但是线程是按顺序执行的，并不是并发执行的。
原因就在于AsyncTask默认的任务加入线程池的方式是串行的方式加入的，也就是内部类SerialExecutor，前面有提到

 public synchronized void execute(final Runnable r) {
        	//入队一个Runnable，run方法跑的是之前传进去的WorkerRunnable的参数
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                    	//先执行当前run方法
                        r.run();
                    } finally {
                    	//再取出队列中的第一个
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

如果要改变的话，只能修改Executor了，但是…

	/** @hide */
    public static void setDefaultExecutor(Executor exec) {
        sDefaultExecutor = exec;
    }

修改的方法又被隐藏了，外界无法调用。但是我们还有一个executeOnExecutor：

并发执行

   public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {}

该方法多接收了一个Executor对象。咱们传入一个线程池就行。这样就是并行了。

new MyAsyncTask().executeOnExecutor(THREAD_POOL_EXECUTOR, new ArrayList());

07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  0  threadName:  AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  1  threadName:  AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  2  threadName:  AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  3  threadName:  AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  4  threadName:  AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  0  threadName:  AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  1  threadName:  AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  0  threadName:  AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  2  threadName:  AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  1  threadName:  AsyncTask #1
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  3  threadName:  AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  0  threadName:  AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  4  threadName:  AsyncTask #6
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  1  threadName:  AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  2  threadName:  AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  3  threadName:  AsyncTask #2
07-11 16:24:28.907 2050-2050/com.example.study I/task: i:  4  threadName:  AsyncTask #2
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  2  threadName:  AsyncTask #1
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  3  threadName:  AsyncTask #1
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  4  threadName:  AsyncTask #1
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  0  threadName:  AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  1  threadName:  AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  2  threadName:  AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  3  threadName:  AsyncTask #7
07-11 16:24:28.917 2050-2050/com.example.study I/task: i:  4  threadName:  AsyncTask #7

所以：