zoukankan      html  css  js  c++  java
  • 源码篇——AsyncTask机制

    AsyncTask

    new AsyncTask<String,String,String>(){
        // 运行在主线程中,做预备工作
        onPreExecute(){
    
        }
        // 运行在子线程中,做耗时操作
        String doingBackGround(String s){
    
        }
        // 运行在主线程中,耗时操作完成,更新UI
        onPostExecute(String s){
    
        }
    
    }.execute(String);
    

    AsyncTask的execute方法

    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
            ...
    
            mStatus = Status.RUNNING;
            // 在主线程中执行准备操作
            onPreExecute();
            // 把params参数赋值给mWorker
            mWorker.mParams = params;
            // 用线程池执行mFuture
            sExecutor.execute(mFuture);
    
    // 在AsyncTask构造方法中创建了mWorker
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
               ...
            }
        };
    
        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                ...
            }
        };
    }
        // 把mWorker传递给FutureTask,callable指的就是mWorker
        public FutureTask(Callable<V> callable) {
                if (callable == null)
                    throw new NullPointerException();
                sync = new Sync(callable);
            }
        // 把mWorker传递给Sync,callable指的是mWorker
        Sync(Callable<V> callable) {
                    this.callable = callable;
                }
    

    线程池执行FutureTask,就是执行FutureTask的run方法,代码如下:

        public void run() {
                // 转调
                sync.innerRun();
            }
    
        void innerRun() {
                    if (!compareAndSetState(READY, RUNNING))
                        return;
    
                    runner = Thread.currentThread();
                    if (getState() == RUNNING) { // recheck after setting thread
                        V result;
                        try {
                            // 就是调用了mWorker.call方法
                            // 把耗时操作得到的结果赋值给result
                            result = callable.call();
                        } catch (Throwable ex) {
                            setException(ex);
                            return;
                        }
                        // 转调了sync.innerSet(v);
                        set(result);
                    } else {
                        releaseShared(0); // cancel
                    }
                }
    
        mWorker = new WorkerRunnable<Params, Result>() {
                    public Result call() throws Exception {
                        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                        // 执行耗时操作 在子线程中执行
                        return doInBackground(mParams);
                    }
                };
    
        protected void set(V v) {
                // 转调
                sync.innerSet(v);
            }
    
        void innerSet(V v) {
                    for (;;) {
                        int s = getState();
                        if (s == RAN)
                            return;
                        if (s == CANCELLED) {
                            // aggressively release to set runner to null,
                            // in case we are racing with a cancel request
                            // that will try to interrupt runner
                            releaseShared(0);
                            return;
                        }
                        if (compareAndSetState(s, RAN)) {
                            result = v;
                            releaseShared(0);
                            // 调用了FutureTask的抽象方法
                            done();
                            return;
                        }
                    }
                }
    
        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                Message message;
                Result result = null;
    
                try {
                    // 转调了sync.innerGet()
                    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
                message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                        new AsyncTaskResult<Result>(AsyncTask.this, result));
                message.sendToTarget();
            }
        };
    
        public V get() throws InterruptedException, ExecutionException {
                // 转调
                return sync.innerGet();
            }
    
        V innerGet() throws InterruptedException, ExecutionException {
                    acquireSharedInterruptibly(0);
                    if (getState() == CANCELLED)
                        throw new CancellationException();
                    if (exception != null)
                        throw new ExecutionException(exception);
                    // 把之前doinBackground方法的结果返回
                    return result;
                }
    

    在AsyncTask的成员变量,创建了InternalHandler

    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
                    // 结束耗时操作完成后的消息
                    // 调用了AsyncTask的finish方法传递的result.mData[0]就是之前
                    // 耗时操作返回来的结果
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
                case MESSAGE_POST_CANCEL:
                    result.mTask.onCancelled();
                    break;
            }
        }
    }
    
    private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;
        // data 是返回的结果
        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
    
    private void finish(Result result) {
        if (isCancelled()) result = null;
        // 耗时操作完成,更新UI,执行在主线程
        onPostExecute(result);
        mStatus = Status.FINISHED;
    }
  • 相关阅读:
    html上传图片后,在页面显示上传的图片
    arcgis 将日期字段赋值为当前日期
    一些使用文件夹重定向的系统中,运行ArcToolbox中的GP工具报IE脚本错误
    Gps中的 gpx文件和excel文件互相转换方法
    ARCMAP 本文将描述如何利用识别工具显示一幅与要素相关的图片。
    arcgis 正确显示标注的大小写
    在一些系统中,运行ArcToolbox中的任何GP工具报Microsoft脚本错误,并且工具对话框显示为空白
    arcgis Howto: 用空格作为分隔符提取字符串中的字符并赋值到另一个新字段
    使用.Net开发ArcGIS9扩展组件的注册到ArcMAP中
    arcgis 利用DEM寻找最小阻力路径 来自http://support.esrichinabj.cn/2008/0325/1189.html
  • 原文地址:https://www.cnblogs.com/xiaowangba/p/6314887.html
Copyright © 2011-2022 走看看