自10年大量看源码后,很少看了,抽时间把最新的源码看看!
public abstract class AsyncTask<Params, Progress, Result> {
    private static final String LOG_TAG = "AsyncTask";
 
    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);
 
    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    private static final int MESSAGE_POST_CANCEL = 0x3;
 
    private static final InternalHandler sHandler = new InternalHandler();
 
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
 
    private volatile Status mStatus = Status.PENDING;
 
    /**
     * Indicates the current status of the task. Each status will be set only once
     * during the lifetime of a task.
     */
    public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         */
        PENDING,
        /**
         * Indicates that the task is running.
         */
        RUNNING,
        /**
         * Indicates that {@link AsyncTask#onPostExecute} has finished.
         */
        FINISHED,
    }
 
    /**
     * 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 {
                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();
            }
        };
    }
 
    /**
     * Returns the current status of this task.
     *
     * @return The current status.
     */
    public final Status getStatus() {
        return mStatus;
    }
   
    protected abstract Result doInBackground(Params... params); 
    protected void onPreExecute() {
    }
 
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onPostExecute(Result result) {
    }
  
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onProgressUpdate(Progress... values) {
    }

protected void onCancelled() {
    }
 
   
    public final boolean isCancelled() {
        return mFuture.isCancelled();
    }
 
     
    public final boolean cancel(boolean mayInterruptIfRunning) {
        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);
    }
 
    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;
    }
 
    protected final void publishProgress(Progress... values) {
        sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
 
    private void finish(Result result) {
        onPostExecute(result);
        mStatus = Status.FINISHED;
    }
 
    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;
                case MESSAGE_POST_CANCEL:
                    result.mTask.onCancelled();
                    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的全部代码。
-----------------------------------------------------------------
    AsyncTask多用于Android的Context(Activity)处理后台逻辑同时又要兼顾主线程的一些逻辑(比如说Activity的UI更新)。
    AsyncTask它其实是封装了一个多线程、向开发者屏蔽了考虑多线程的问题。开发人员只需去重写AsyncTask中的doInBackground、onProgressUpdate、onPreExecute、onPostExecute等方法,然后生成该对象并执行execute方法即可实现异步操作。

由于Android负责Context(Activity)的主线程(或者说是UI控制线程)不是线程安全的,也就是说开发者不能在自己生成的线程对象里面操作Activity的UI更新。
    对于习惯了Java开发的开发人员来说,非要自己生成线程对象,在这个线程里操作一些时间较长的逻辑(比如下载文件),完成之后再提醒用户下载完成(UI更新,比如在一个TextView中把文字修改成"下载完成")的话,那么UI更新的工作只能借助于Handler(这个Handler必须是在主线程中生成,或者说和主线程共用一个Looper和MessageQueue,通常的方法是在Activity中的onCreate方法中生成重写的Handler对象)。当开发者的线程完成逻辑操作之后,发送一个消息到Handler,再由Handler去处理。如果Handler由主线程生成,那么这个Handler的handleMessage()会在主线程中执行,因此在handleMessage()中可以访问Activity中的某个View并修改。如一下代码:

public class TestActivity extends Activity{
       private static final int WHAT = 0x01;<br>
       private Thread downloadThread;
       private Handler refleshHandler;
  
       @Override
    protected void onCreate(Bundle savedInstanceState) {
        setContentView(R.layout.main);
        super.onCreate(savedInstanceState);
          
                  
        downloadThread = new Thread(new DownloadRunnable());
        refleshHandler = new RefleshHandler();
        downloadThread.start();
 
    }
     
    private class DownloadRunnable implements Runnable { 
    public void run() {
            System.out.println("开始处理业务"); 
            //耗时较长的逻辑代码省略
            refleshHandler.sendEmptyMessage(WHAT);
        }
    }
     
    private class RefleshHanler extends Handler{
        @Override
        public void handleMessage(Message msg) { 
            if(msg.what == WHAT){
            //更新TestActivity UI
        }
    }
}
上述的方法也未尝不是一种好的方法。然而Android为开发者提供了一种新的解决方案,那就是AsyncTask,分析完源代码会发现,其实AsyncTask为我们封装了上述的方法。

对于我们重写AsyncTask的doInBackground()的方法,AsyncTask会将它封装成一个实现Callable接口的对象,在线程池中找出一个线程是实现它,因此我们所需要的耗时较长的逻辑可以放在这个方法里面。

AsyncTask也维护着一个静态的Handler,这个Handler属于创建AsyncTask的线程,而创建AsyncTask一般都是主线程(UI线程),因此这个Handler可以访问并Activity的UI。

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;
                case MESSAGE_POST_CANCEL:
                    result.mTask.onCancelled();
                    break;
            }
        }
    }
可以看到这个Handler操作了AsyncTask的三个方法:finish() , onProgressUpdate() , onCancelled(),而finish() 又调用onPostExecute()方法。
     可以这么说,onProgressUpdate() ,onCancelled(),onPostExecute() 用来被开发者重写,去更新UI的,这3个方法会涉及到UI的操作,因此doInBackground()方法里不能调用这几个方法,也就是说开发者可以重写这些方法,但是又不能直接调用这些方法,只能通过发送消息给Handler的方式来隐式的调用。

onProgressUpdate()是一个更新处理进度的方法,开发者可以重写它,可以将它关联到Activity的一个进度条控件上,在doInBackground()里可以用publishProgress()去间接调用它(其实这个函数也是通过发送what为MESSAGE_POST_PROGRESS的Message给Handler的方式来调用onProgressUpdate()的),这样就能在UI上显示进度信息。
     finish()方法,也就是onPostExecute(),是处理完doInBackground()得到结果之后的调用。doInBackground()的函数封装在实现Callable接口的名叫一个WorkerRunnable的抽象类中,再将这个类封装在Future中,并重写Future的done()方法,这个方法会在Callable的call方法执行完之后调用,就是doInBackground()方法执行完之后调用,它可以获得执行完的结果,Future.get()方法(可能阻塞),并将得到的结果封装在what为MESSAGE_POST_RESULT的Message中,并发送。上诉的核心代码如下:
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }
    
     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();
            }
        };

同理,onCancelled()是在AsyncTask被取消时的调用,也是通过Handler的方法。
    有一点要注意到,还有一个onPreExecute()方法,虽然这个方法是未被Handler加入到消息处理的方法里,但是这个方法是在execute()里执行的,execute是主线程(UI线程)才会去执行的,所以这个方法也能访问和修改UI。

总结:  开发者可以重写AsyncTask的onProgressUpdate() , onCancelled(), onPostExecute(), onPreExecute(), doInBackground()方法,以得到异步实现后台逻辑并更新UI的操作。

其中onProgressUpdate() , onCancelled(), onPostExecute(), onPreExecute() 可以直接访问并修改UI。

但是doInBackground()不能出现涉及UI的操作,也不能直接调用onProgressUpdate() , onCancelled(), onPostExecute(), onPreExecute() 这四个方法,后三者不需要调用,可以通过publishProgress()去间接的调用onProgressUpdate()方法。

最后要说的是AsyncTask的对象一旦生成之后,execute()方法只能被调用一次,即使是同样的操作,也需要重新生成AsyncTask对象才行。

Android AsyncTask运作原理和源码分析的更多相关文章

  1. Android Debuggerd 简要介绍和源码分析(转载)

    转载: http://dylangao.com/2014/05/16/android-debuggerd-%E7%AE%80%E8%A6%81%E4%BB%8B%E7%BB%8D%E5%92%8C%E ...

  2. Java并发编程(七)ConcurrentLinkedQueue的实现原理和源码分析

    相关文章 Java并发编程(一)线程定义.状态和属性 Java并发编程(二)同步 Java并发编程(三)volatile域 Java并发编程(四)Java内存模型 Java并发编程(五)Concurr ...

  3. Kubernetes Job Controller 原理和源码分析(一)

    概述什么是 JobJob 入门示例Job 的 specPod Template并发问题其他属性 概述 Job 是主要的 Kubernetes 原生 Workload 资源之一,是在 Kubernete ...

  4. Kubernetes Job Controller 原理和源码分析(二)

    概述程序入口Job controller 的创建Controller 对象NewController()podControlEventHandlerJob AddFunc DeleteFuncJob ...

  5. Kubernetes Job Controller 原理和源码分析(三)

    概述Job controller 的启动processNextWorkItem()核心调谐逻辑入口 - syncJob()Pod 数量管理 - manageJob()小结 概述 源码版本:kubern ...

  6. Android IntentService的使用和源码分析

    引言 Service服务是Android四大组件之一,在Android中有着举足重轻的作用.Service服务是工作的UI线程中,当你的应用需要下载一个文件或者播放音乐等长期处于后台工作而有没有UI界 ...

  7. Java1.7 HashMap 实现原理和源码分析

    HashMap 源码分析是面试中常考的一项,下面一篇文章讲得很好,特地转载过来. 本文转自:https://www.cnblogs.com/chengxiao/p/6059914.html 参考博客: ...

  8. 深入ReentrantLock的实现原理和源码分析

    ReentrantLock是Java并发包中提供的一个可重入的互斥锁.ReentrantLock和synchronized在基本用法,行为语义上都是类似的,同样都具有可重入性.只不过相比原生的Sync ...

  9. ☕【Java深层系列】「并发编程系列」让我们一起探索一下CyclicBarrier的技术原理和源码分析

    CyclicBarrier和CountDownLatch CyclicBarrier和CountDownLatch 都位于java.util.concurrent这个包下,其工作原理的核心要点: Cy ...

随机推荐

  1. 想弄清楚LIBEVENT和EPOLL之类的关系,不要因为走得太急而迷失了方向

    要一步一步构架起整个体系, 来日方长. 系统调用级别的EPOLL和函数库LIBEVENT之间,大体关系应该是如何呢? 网上有说法: ~~~~~~~~~~~~~~ libevent对底层多路复用机制的封 ...

  2. UINavigationController使用的注意事项

    1.常用属性viewControllers //所有在栈中的控制器topViewController //栈顶控制器navigationBar //导航栏 竖屏下默认44,横屏默认32 2.对navi ...

  3. 找不到mysql服务或mysql服务名无效

    问题原因:mysql服务没有安装. 解决办法: 在 mysql bin目录下 以管理员的权限 执行 mysqld -install命令 出现:Service successfully installe ...

  4. VC++下封装ADO类以及使用方法

    操作系统:windows 7软件环境:visual studio 2008 .Microsoft SQL 2005本次目的:介绍一个已经封装的ADO类,简单说明怎么导入使用 首先声明一下,这个封装的A ...

  5. Android 三档自定义滑动开关,禁止点击功能的实现,用默认的seekbar组件实现

    android三档自定义滑动开关,禁止点击功能的实现,普通开关网上有很多例子,三档滑动开关的则找了整天都没有相关例子,开始用普通开关的源码修改了自己实现了一个类,但效果不如人意,各种边界情况的算法很难 ...

  6. 存储过程系列之存储过程具体操作过程及sql数据库调用

    Transact-SQL中的存储过程,非常类似于Java语言中的方法,它可以重复调用.当存储过程执行一次后,可以将语句缓存中,这样下次执行的时候直接使用缓存中的语句.这样就可以提高存储过程的性能. 存 ...

  7. 用U盘安装系统

    下述的前提就是:如果你想要装win7,win8系统的话,你需要准备一个大于等于4G的U盘,但是如果你想装XP,Ubuntu等小系统就可以只要1G的U盘就行了,温馨提示,记得将U盘里的重要东西移走,因为 ...

  8. ARM-Linux配置DHCP自动获取IP地址

    备注:内核版本:2.6.30.9busybox版本:1.15.2 PC Linux和开发板Linux的工作用户:root 1. 配置内核:[*] Networking support --->N ...

  9. HDU5673 Robot 默慈金数

    分析: 注:然后学了一发线性筛逆元的姿势 链接:http://blog.miskcoo.com/2014/09/linear-find-all-invert #include<iostream& ...

  10. Oracle.ManagedDataAccessDTC.dll 使用

    ODP.NET, Managed Driver Setup This section explains the setup and configuration steps required for u ...