Androidの最も詳しいAsyncTaskソースの剖析

11836 ワード

最近Androidスレッドの最適化に関する知識をまとめています.ちなみにAsyncTaskは、googleが出てきた最初のパッケージクラスであり、私たちがよく使う操作スレッドでもあります.次に、深く勉強して振り返ってみましょう.
一、簡単な使用と紹介(会の学生は直接ソース分析をスキップすることができる)

見てdemo

  //execute
  NumAsyncTask numAsyncTask = new NumAsyncTask();
  numAsyncTask.execute();
  
   ------------------------------------
  
  private class NumAsyncTask extends AsyncTask{
  
     @Override
     protected Void doInBackground(Void... voids) {
              for (int i = 0; i < 8; i++)
              {
                       try
                       {
                                Thread.sleep(100);
                       } catch (InterruptedException e)
                       {
                                e.printStackTrace();
                       }
                       publishProgress(i);
                       Log.e(TAG, "doInBackground   :  for -"+i+"  "+Thread.currentThread().getName());
              }
              return null;
     }
  
     @Override
     protected void onPreExecute() {
              super.onPreExecute();
              Log.e(TAG, "onPreExecute   : "+Thread.currentThread().getName());
     }
  
     @Override
     protected void onPostExecute(Void aVoid) {
              super.onPostExecute(aVoid);
              Log.e(TAG, "onPostExecute   : "+Thread.currentThread().getName());
     }
  
     @Override
     protected void onProgressUpdate(Integer... values) {
              super.onProgressUpdate(values);
              Log.e(TAG, "onProgressUpdate   : "+values[0]+"    " +Thread.currentThread().getName());
     }
  
     @Override
     protected void onCancelled() {
              super.onCancelled();
              Log.e(TAG, "onCancelled   : "+Thread.currentThread().getName());
     }
  }

実行結果

  $NumAsyncTask: onPreExecute   : main                         
  $NumAsyncTask: doInBackground   :  for -0  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 0    main                
  $NumAsyncTask: doInBackground   :  for -1  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 1    main                
  $NumAsyncTask: doInBackground   :  for -2  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 2    main                
  $NumAsyncTask: doInBackground   :  for -3  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 3    main                
  $NumAsyncTask: doInBackground   :  for -4  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 4    main                
  $NumAsyncTask: doInBackground   :  for -5  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 5    main                
  $NumAsyncTask: doInBackground   :  for -6  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 6    main                
  $NumAsyncTask: doInBackground   :  for -7  AsyncTask #1      
  $NumAsyncTask: onProgressUpdate   : 7    main                
  $NumAsyncTask: onPostExecute   : main

上から分かるように、実行の順番は次のとおりです.

onPreExecuteメインスレッドで準備作業を行う

doInBackgroundサブスレッドでの時間のかかる操作

onProgressUpdateはUIメインスレッドでサブスレッド処理の結果を受け入れて表示できる

onPostExecuteサブスレッド処理完了、UIスレッド更新

手軽に使えるので、ソースコードについて詳しく見ていきましょう.

二、ソースの剖析
異なるAndroidソースコードが出入りする可能性があります.これはAndroid API 20に基づいています.
1.まずAsyncTask初期化から

public abstract class AsyncTask {

AsyncTask抽象クラスに注釈が山積みになっていることに気づき、使い方を教えてくれます.簡単に見ると、AsyncTaskは主にUI Threadを簡単に使用し、ThreadやHandleの使用を補助するために使用されています.サブスレッドの短時間操作(数秒程度)に使用し、長時間スレッドプールを使用することをお勧めします.

AsyncTaskの接尾辞パターンを見てみると、3つのパラメータがそれぞれ(後述):

Params:タスクに送信するパラメータタイプ

Progress:その間にリリースされる進捗タイプ

Result:バックグラウンド結果のタイプ

観賞類の初期化

  1 --------->     mHandler， new   mWorker，    
      * call           doInBackground(mParams);---      
  public AsyncTask(@Nullable Looper callbackLooper) {
      mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
          ? getMainHandler()
          : new Handler(callbackLooper);

      mWorker = new WorkerRunnable() {
          public Result call() throws Exception {
              mTaskInvoked.set(true);
              Result result = null;
              try {
                  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                  //noinspection unchecked
                  result = doInBackground(mParams);
                  Binder.flushPendingCommands();
              } catch (Throwable tr) {
                  mCancelled.set(true);
                  throw tr;
              } finally {
                  postResult(result);
              }
              return result;
          }
      };

  2 --------->mWorker   Callable
 private static abstract class WorkerRunnable implements Callable {
      Params[] mParams;
  }

2.mWorkerでcallメソッドを実装しdoInBackgroundを呼び出す

callではまずプロセスレベルを設定する.THREAD_PRIORITY_BACKGROUND-10

doInBackgroundを呼び出し、workerに保存されているparamsを操作する

Binder.flushPendingCommands():コマンドチャネルbinder driverをリフレッシュし、長時間のプロセス保有リソース解放処理

finallyでpostResult(result)が呼び出され、resultは初期化時に汎用宣言の戻り結果タイプ

 1 --------->

 private Result postResult(Result result) {
     @SuppressWarnings("unchecked")
     Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
             new AsyncTaskResult(this, result));
     message.sendToTarget();
     return result;
 }


 2 --------->            ，    Task Data（     ）

 private static class AsyncTaskResult {
 final AsyncTask mTask;
 final Data[] mData;

 AsyncTaskResult(AsyncTask task, Data... data) {
         mTask = task;
         mData = data;
     }
 }
 
 3 --------->getHandler           

 private Handler getHandler() {
     return mHandler;
 }

3.Handlerによるメッセージングメカニズムを見る

getMainHandler、メインスレッドのLooper

    private static Handler getMainHandler() {
          synchronized (AsyncTask.class) {
              if (sHandler == null) {
                  sHandler = new InternalHandler(Looper.getMainLooper());
              }
              return sHandler;
          }
      }

InternalHandlerとpublishProgress:

  1 --------->  result progress    

  private static class InternalHandler extends Handler {
      public InternalHandler(Looper looper) {
          super(looper);
      }

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

  2 --------->finish：  ，     ：FINISHED
      *              onCancelled
      *      onPostExecute   ，   result
  
   private void finish(Result result) {
      if (isCancelled()) {
          onCancelled(result);
      } else {
          onPostExecute(result);
      }
      mStatus = Status.FINISHED;
  }


  3 --------->  publishProgress，    Handler    ，    progress   

  protected final void publishProgress(Progress... values) {
      if (!isCancelled()) {
          getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                  new AsyncTaskResult(this, values)).sendToTarget();
      }
  }

4.次にexecuteメソッドを見る

まずコメントですが、Android API 11から、シングルスレッド実行に変更し、並行したい場合はexecuteOnExecutorを使用してスレッドプール管理に転送

コードを見る:

  1 --------->    ，params       （     ，   ）
  @MainThread
  public final AsyncTask execute(Params... params) {
      return executeOnExecutor(sDefaultExecutor, params);
  }


  2 --------->executeOnExecutor   sDefaultExecutor
    *    2   ：RUNNING，FINISHED，      ，     ，          
    *          onPreExecute();
    *  mWorker        params

  public final AsyncTask 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;
  }
  
  3 --------->     ，   sDefaultExecutor.execute,    FutureTask

5.スレッドプールsDefaultExecuterおよびexecuteメソッドを参照

sDefaultExecutorメンバー変数で宣言

  private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

  public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

SerialExecutorを見て、AsyncTaskのプライベート静的内部クラス:

    1 ---------> execute   ， mTasks     ，      Runnable
        *        ，      THREAD_POOL_EXECUTOR     
        
    private static class SerialExecutor implements Executor {
        final ArrayDeque mTasks = new ArrayDeque();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

スレッドプールTHREADを見るPOOL_EXECUTOR:

    1 --------->          ，    ：
        *        2-4
        *           CPU     CPU_COUNT * 2 + 1，
        * KEEP_ALIVE_SECONDS
        *      sPoolWorkQueue，  128
    
    
    private static final BlockingQueue sPoolWorkQueue =
        new LinkedBlockingQueue(128);
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    // We want at least 2 threads and at most 4 threads in the core pool,
    // preferring to have 1 less than the CPU count to avoid saturating
    // the CPU with background work
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;

    public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

三、まとめ
AsyncTaskのソースコードは上から分析が終わり、非常に簡単に見えますが、設計はすべて非常に全面的で便利です.理解を深めるには、Android非同期メカニズム、Handler、Javaスレッドプールの学習を詳しく理解する必要があります.私の後続の一連のソース分析を参考にして、一緒に探求して勉強することができます.

HTMLとは

DockerとKubernetesのPerlのための2、3のヒント