王学岗异步机制 AsyncTask

来源：互联网发布：python 字典 list 编辑：程序博客网时间：2024/04/29 07:38

我们先从源码入手，
先看 AsyncTask类

 private static final int CORE_POOL_SIZE = 5;

表示核心线程数量为5；

 private static final int MAXIMUM_POOL_SIZE = 128;

AsyncTask最多可以有128个线程
即最多可以存在128个线程，最多可以有5个线程并发运行

  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 BlockingQueue<Runnable> sPoolWorkQueue =            new LinkedBlockingQueue<Runnable>(10);

线程池队列，队列中最多可以存在10个对象

private static final InternalHandler sHandler = new InternalHandler();

新建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;            }        }    }

在handler里执行onProgressUpdate(result.mData)方法，不断的更新UI线程

 public static void init() {        sHandler.getLooper();    }

这里得到消息泵(loop)

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

创建了一个工作线程，相当于new了一个Theead

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

在结束的时候调用了onPostExecute(result)；

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

构造方法里调用 onPreExecute()；

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

doInBackground(mParams)在子线程里面执行

0 0