AsyncTask原理浅见

最新推荐文章于 2022-09-15 23:20:37 发布

gujiaogu

最新推荐文章于 2022-09-15 23:20:37 发布

阅读量801

点赞数

CC 4.0 BY-SA版权

分类专栏： android 文章标签： thread exception null ui class

本文链接：https://blog.youkuaiyun.com/gujiaogu/article/details/7204399

android 专栏收录该内容

4 篇文章

订阅专栏

本文详细解析了Android中AsyncTask的工作机制，包括线程池的创建、FutureTask的使用及UI线程的通知方式。通过四个主要步骤揭示AsyncTask如何实现后台任务处理与主线程交互。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

AsyncTask的基原理是创建一个线程池，通过线程池执行一个Runnable对象（FutureTask），然后通过Handler通知UI线程。

1、线程池的创建。创建线程池，并返回一个执行器对象（Executor）

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAXIMUM_POOL_SIZE = 128;
    private static final int KEEP_ALIVE = 10;

    private static final BlockingQueue<Runnable> sWorkQueue =
            new LinkedBlockingQueue<Runnable>(10);

    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());
        }
    };
   private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
            MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

2、将被执行的Runnable对象（FutureTask）的创建。在构造方法中创建FutureTask。

 public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                return doInBackground(mParams);
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                Message message;
                Result result = null;

                try {
                    result = 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) {
                    message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,
                            new AsyncTaskResult<Result>(AsyncTask.this, (Result[]) null));
                    message.sendToTarget();
                    return;
                } catch (Throwable t) {
                    throw new RuntimeException("An error occured while executing "
                            + "doInBackground()", t);
                }

                message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                        new AsyncTaskResult<Result>(AsyncTask.this, result));
                message.sendToTarget();
            }
        };
    }

其中WorkRunnable是一个Callable对象：

    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

3、执行，execute方法。

public final AsyncTask<Params, Progress, Result> execute(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;
        sExecutor.execute(mFuture);

        return this;
    }

4、使用Handler通知UI线程，在上面的第二步中最后两行代码。