AsyncTask源码解析

梦里梦外; 2022-11-18 01:52 189阅读 0赞

# 前言 #

在旧时`AsyncTask`和`Handler`作为两个异步框架，但如今Google已在文档中废弃了`AsyncTask`推荐使用[Kotlin协程][Kotlin].但是源码分析依然可以学到很多有用的东西。

# 简单的使用 #

class MainActivity : AppCompatActivity() {
        
        override fun onCreate(savedInstanceState: Bundle?) {
        
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            val myAsyncTask = MyAsyncTask()
    
            myAsyncTask.execute(0)
    
        }
    
       class MyAsyncTask : AsyncTask<Int,String,Int>(){
        
    
           /**
            * 1. 异步任务运行前的回掉
            * 运行在主线程
            */
           override fun onPreExecute() {
        
                super.onPreExecute()
                log("onPreExecute ")
            }
           /**
            * 1. 异步任务处理函数
            * 运行在子线程
            */
            override fun doInBackground(vararg params: Int?): Int {
        
                log("doInBackground [${params[0]}]")
                var current=0;
    
                while (current<=5){
        
                    current++;
                    publishProgress("当前进度[$current]")
    
                }
    
                return  current;
            }
    
           /**
            * 3. 在doInBackground调用publishProgress的时候回掉
            *    线程在主线程
            */
           override fun onProgressUpdate(vararg values: String) {
        
               super.onProgressUpdate(*values)
               log("onProgressUpdate ${values}")
    
           }
           /**
            * 4. 任务完成的时候回调
            *    线程在主线程
            */
           override fun onPostExecute(result: Int) {
        
               super.onPostExecute(result)
               log("onPostExecute ${result}")
    
           }
           fun log(msg:String){
        
               Log.e("AsyncTask","Thread[${Thread.currentThread().name}]  msg[${msg}]")
           }
    
    
       }
    
    
    }

输出：

Thread[main]  msg[onPreExecute ]
    Thread[AsyncTask #1]  msg[doInBackground [0]]
    Thread[main]  msg[onProgressUpdate [Ljava.lang.String;@17a91a72]
    Thread[main]  msg[onProgressUpdate [Ljava.lang.String;@3f3b2ec3]
    Thread[main]  msg[onProgressUpdate [Ljava.lang.String;@22448340]
    Thread[main]  msg[onProgressUpdate [Ljava.lang.String;@3aa99279]
    Thread[main]  msg[onProgressUpdate [Ljava.lang.String;@276a6bbe]
    Thread[main]  msg[onProgressUpdate [Ljava.lang.String;@817f41f]
    Thread[main]  msg[onPostExecute 6]

由于用法比较简单这里就不再说明

# 版本迁移问题 #

`AsyncTask`随着多次版本提升，默认的执行`AsyncTask.execute()`函数所在的线程池也发生了变化。

**Android 1.5**  
串行执行

**Android 1.6到Android 3.0以下**  
并发运行

**Android3.0后**  
串行执行  
但是同时多了一个API，允许我们自定义运行所在的线程池`AsyncTask.executeOnExecutor()`

这里串行执行不代表是单线程池，而是同一个`AsyncTask`多次同时运行`execute`时,  
只会按顺序运行。  
比如：

val myAsyncTask = MyAsyncTask()
    //这里假设为A
    myAsyncTask.execute(0)
    //假设这里为B
    myAsyncTask.execute(1)
    //假设这里为C
    myAsyncTask.execute(1)

上面的例子 只有执行完成`A`,在执行完成`B`,最后在执行`C`

val myAsyncTask = MyAsyncTask()
    //这里假设为A
    myAsyncTask.execute(0)
    
    
    val myAsyncTask2 = MyAsyncTask()
    
    //假设这里为B
    myAsyncTask2.execute(1)

上面我们构造了两个`MyAsyncTask`，并且在同时执行了`execute`，那么会`A`和`B`会同时执行

# Android5.0 源码分析 #

val myAsyncTask = MyAsyncTask()
    myAsyncTask.execute(0)

class AsyncTask {
        
     //单线程线程池
     private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
     //我们看下SerialExecutor实现类
     public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    
     public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        
     		//sDefaultExecutor是一个内置的线程池
            return executeOnExecutor(sDefaultExecutor, params);
        }
     public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) {
        
         
            mStatus = Status.RUNNING;
    		//运行
            onPreExecute();
    
            mWorker.mParams = params;
            exec.execute(mFuture);
    
            return this;
        }
    
    	
    	/**
    	** 线程池的处理
    	**/
    
    	//得到CPU核心数目
        private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
        //CPU+1
        private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
        //最大的线程池数量
        private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
        //空闲线程的存活时间
        private static final int KEEP_ALIVE = 1;
        //注意这里不是单线程线程池，而是一个适合与IO密集型的线程池
        //为什么适合CPU密集型，不属于这个文章讨论范围，可以简单理解，CPU密集型线程数应该紧贴CPU核心数
        //需要留意这个线程的由于没指定线程满时拒绝策略，所以为AbortPolicy。所以过多任务提交时直接抛出异常
      	public static final Executor THREAD_POOL_EXECUTOR
                = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                        TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
    
    
    
    
    
    
     //串行思想实现处
     private static class SerialExecutor implements Executor {
        
            final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
            Runnable mActive;
    
            public synchronized void execute(final Runnable r) {
        
            	//推入一个双端队列中，
                mTasks.offer(new Runnable() {
        
                    public void run() {
        
                        try {
        
                        	//运行执行的任务
                            r.run();
                        } finally {
        
                        	//运行完成后在执行下一个任务串行执行
                            scheduleNext();
                        }
                    }
                });
                //第一次运行的时候为null。
                if (mActive == null) {
        
                    scheduleNext();
                }
            }
    
            protected synchronized void scheduleNext() {
        
                if ((mActive = mTasks.poll()) != null) {
        
                    THREAD_POOL_EXECUTOR.execute(mActive);
                }
            }
        }
    
    }

[Kotlin]: https://developer.android.com/topic/libraries/architecture/coroutines