• WorkManager 一篇文章就够了

    使用篇

    首先引入WorkManager库（使用java和kotlin引入库不同，需要注意）：

    1. // Kotlin + coroutines
    2. implementation 'androidx.work:work-runtime-ktx:2.7.1'

    单任务场景

    我们开始来写一个最简单的使用，先写一个Worker：

    1. const val TAG = "UploadWorker"
    2.  
    3. class UploadWorker(appContext: Context, workerParameters: WorkerParameters) :
    4.     Worker(appContext, workerParameters) {
    5.  
    6.     override fun doWork(): Result {
    7.         Thread.sleep(6000)
    8.         Log.d(TAG, "lzy是大帅哥！")
    9.         return Result.success()
    10.     }
    11.  
    12. }

    注意：这个doWork方法是异步的，后面分析源码时会讲到。

    我们首先来个一次性任务：

    1. class MainActivity : AppCompatActivity() {
    2.  
    3.     override fun onCreate(savedInstanceState: Bundle?) {
    4.         super.onCreate(savedInstanceState)
    5.         setContentView(R.layout.activity_main)
    6.         initView()
    7.     }
    8.  
    9.     private fun initView() {
    10.         val btn = findViewById
    11.         btn.setOnClickListener {
    12.             val oneTimeWorkRequest = OneTimeWorkRequest
    13. .Builder(UploadWorker::class.java).build()
    14.             WorkManager.getInstance().enqueue(oneTimeWorkRequest)
    15.         }
    16.     }
    17.  
    18. }

    OneTimeRequest顾名思义就是一个一次性任务，然后通过enqueue方法放到workmanager里面去执行。

    布局文件：

    2. <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    3.     xmlns:app="http://schemas.android.com/apk/res-auto"
    4.     xmlns:tools="http://schemas.android.com/tools"
    5.     android:layout_width="match_parent"
    6.     android:layout_height="match_parent"
    7.     tools:context=".MainActivity">
    8.  
    9.     <LinearLayout
    10.         android:layout_width="match_parent"
    11.         android:layout_height="match_parent"
    12.         android:orientation="vertical"
    13.         >
    14.  
    15.         <Button
    16.             android:id="@+id/btn_01"
    17.             android:layout_width="match_parent"
    18.             android:layout_height="50dp"
    19.             android:text="测试1"
    20.             />
    21.  
    22.         <Button
    23.             android:layout_marginTop="20dp"
    24.             android:id="@+id/btn_02"
    25.             android:layout_width="match_parent"
    26.             android:layout_height="50dp"
    27.             android:text="测试2"
    28.             />
    29.  
    30.         ···
    31.  
    32.     LinearLayout>
    33.  
    34. androidx.constraintlayout.widget.ConstraintLayout>

    运行效果图：

     点击测试1，等个6s:

    1. 2022-08-13 12:57:51.578 5703-5742/com.example.workmanagertest
    2.  D/UploadWorker: lzy是大帅哥！
    3. 2022-08-13 12:57:51.581 5703-5730/com.example.workmanagertest
    4.  I/WM-WorkerWrapper: Worker result SUCCESS for Work [
    5.  id=74aa4669-28f0-4e20-93fc-2716f4ebc686,
    6.  tags={ com.example.workmanagertest.UploadWorker } ]

    数据互传

    我们工程中一定会有大量activity和WorkManager传递参数的场景，那么该如何传递参数呢？接着往下看：

    1. const val TAG2 = "LzyWorkManager2"
    2.  
    3. class LzyWorkManager2(appContext: Context, var workerParameters: WorkerParameters) :
    4.     Worker(appContext, workerParameters) {
    5.  
    6.     override fun doWork(): Result {
    7.         //接收数据
    8.         val data = workerParameters.inputData.getString("lzy")
    9.         Log.d(TAG2, "$data")
    10.         return Result.success()
    11.     }
    12.  
    13. }
    14.  
    15.  
    16.         val btn2 = findViewById
    17.         btn2.setOnClickListener {
    18.             val sendData = Data.Builder()
    19.                 .putString("lzy", "lzy是个人才啊！")
    20.                 .build()
    21.             val oneTimeWorkRequest = OneTimeWorkRequest
    22.                 .Builder(LzyWorkManager2::class.java)
    23.                 .setInputData(sendData)
    24.                 .build()
    25.             WorkManager.getInstance().enqueue(oneTimeWorkRequest)
    26.         }

    activity里面先构建data，然后通过setInputData传入data，最后woker里面从params里面接收data。既然activity可以向worker里面发送data，那么woker里面该如何回传data呢？接着看：

    1. const val TAG2 = "LzyWorkManager2"
    2.  
    3. class LzyWorkManager2(appContext: Context, var workerParameters: WorkerParameters) :
    4.     Worker(appContext, workerParameters) {
    5.  
    6.     override fun doWork(): Result {
    7.         //接收数据
    8.         val data = workerParameters.inputData.getString("lzy")
    9.         Log.d(TAG2, "$data")
    10.         //回传数据
    11.         val data2 = Data.Builder().putString("st", "st也很帅").build()
    12.         return Result.success(data2)
    13.     }
    14.  
    15. }

    worker里面我们通过Result.success返回数据。再看activity如何处理：

    1. class MainActivity : AppCompatActivity() {
    2.  
    3.     override fun onCreate(savedInstanceState: Bundle?) {
    4.         super.onCreate(savedInstanceState)
    5.         setContentView(R.layout.activity_main)
    6.         initView()
    7.     }
    8.  
    9.     private fun initView() {
    10.         val btn = findViewById
    11.         btn.setOnClickListener {
    12.             val oneTimeWorkRequest = OneTimeWorkRequest.Builder(UploadWorker::class.java).build()
    13.             WorkManager.getInstance().enqueue(oneTimeWorkRequest)
    14.         }
    15.         val btn2 = findViewById
    16.         btn2.setOnClickListener {
    17.             val sendData = Data.Builder()
    18.                 .putString("lzy", "lzy是个人才啊！")
    19.                 .build()
    20.             val oneTimeWorkRequest = OneTimeWorkRequest
    21.                 .Builder(LzyWorkManager2::class.java)
    22.                 .setInputData(sendData)
    23.                 .build()
    24.             WorkManager.getInstance().enqueue(oneTimeWorkRequest)
    25.             WorkManager.getInstance()
    26.                 .getWorkInfoByIdLiveData(oneTimeWorkRequest.id)
    27.                 .observe(this) {
    28.                     val getData = it.outputData.getString("st")
    29.                     Log.d(TAG2, "$getData")
    30.                 }
    31.         }
    32.     }
    33.  
    34. }

    很明显，WorkManager里面又封装了LiveData，是通过LiveData监听数据返回的。

    注：it是WorkInfo类型。

    按下测试2按钮，打印日志：

    1. 2022-08-13 13:35:57.619 6215-6215/com.example.workmanagertest
    2.  D/LzyWorkManager2: null
    3. 2022-08-13 13:35:57.630 6215-6215/com.example.workmanagertest 
    4. D/LzyWorkManager2: null
    5. 2022-08-13 13:35:57.631 6215-6248/com.example.workmanagertest 
    6. D/LzyWorkManager2: lzy是个人才啊！
    7. 2022-08-13 13:35:57.632 6215-6240/com.example.workmanagertest 
    8. I/WM-WorkerWrapper: Worker result SUCCESS for Work
    9.  [ id=7555eb6d-95ab-4a25-8b5d-15b8d4709316, tags=
    10. { com.example.workmanagertest.LzyWorkManager2 } ]
    11. 2022-08-13 13:35:57.645 6215-6215/com.example.workmanagertest 
    12. D/LzyWorkManager2: st也很帅

    我们发现有两个日志打印了null，这是什么原因呢？原来这个LiveData监听的是WorkInfo的状态变化，我们只有当数据拿到后再处理，优化一下代码：

    1. WorkManager.getInstance()
    2.             .getWorkInfoByIdLiveData(oneTimeWorkRequest.id)
    3.              .observe(this) {
    4.                     if (it.state.isFinished) {
    5.                         val getData = it.outputData.getString("st")
    6.                         Log.d(TAG2, "$getData")
    7.                     }
    8.               }

    如果workInfo的状态是完成了，那么：

    1. 2022-08-13 13:50:31.397 6390-6425/com.example.workmanagertest
    2.  D/LzyWorkManager2: lzy是个人才啊！
    3. 2022-08-13 13:50:31.397 6390-6412/com.example.workmanagertest 
    4. I/WM-WorkerWrapper: Worker result SUCCESS for Work
    5.  [ id=b7ea9abe-d89b-4c2c-b4b3-66ddb779f675, 
    6. tags={ com.example.workmanagertest.LzyWorkManager2 } ]
    7. 2022-08-13 13:50:31.401 6390-6390/com.example.workmanagertest 
    8. D/LzyWorkManager2: st也很帅

    这样就过滤掉一些中间状态了。

    多任务场景

    我们多定义几个Woker：

    1. class LzyWorkManager3(appContext: Context, workerParameters: WorkerParameters) :
    2.     Worker(appContext, workerParameters) {
    3.  
    4.     override fun doWork(): Result {
    5.         Log.e(TAG3, "work3 执行了")
    6.         return Result.success()
    7.     }
    8.  
    9. }
    10.  
    11. class LzyWorkManager4(appContext: Context, workerParameters: WorkerParameters) :
    12.     Worker(appContext, workerParameters) {
    13.  
    14.     override fun doWork(): Result {
    15.         Log.e(TAG3, "work4 执行了")
    16.         return Result.success()
    17.     }
    18.  
    19. }
    20.  
    21. class LzyWorkManager5(appContext: Context, workerParameters: WorkerParameters) :
    22.     Worker(appContext, workerParameters) {
    23.  
    24.     override fun doWork(): Result {
    25.         Log.e(TAG3, "work5 执行了")
    26.         return Result.success()
    27.     }
    28.  
    29. }
    30.  
    31. class LzyWorkManager6(appContext: Context, workerParameters: WorkerParameters) :
    32.     Worker(appContext, workerParameters) {
    33.  
    34.     override fun doWork(): Result {
    35.         Log.e(TAG3, "work6 执行了")
    36.         return Result.success()
    37.     }
    38.  
    39. }

    activity里面事件：

    1.         val btn3 = findViewById
    2.         btn3.setOnClickListener {
    3.             val oneTimeWorkRequest3 =
    4.                 OneTimeWorkRequest
    5. .Builder(LzyWorkManager3::class.java).build()
    6.             val oneTimeWorkRequest4 =
    7.                 OneTimeWorkRequest
    8. .Builder(LzyWorkManager4::class.java).build()
    9.             val oneTimeWorkRequest5 =
    10.                 OneTimeWorkRequest
    11. .Builder(LzyWorkManager5::class.java).build()
    12.             val oneTimeWorkRequest6 =
    13.                 OneTimeWorkRequest
    14. .Builder(LzyWorkManager6::class.java).build()
    15.             val requestList = ArrayList()
    16.             requestList.add(oneTimeWorkRequest3)
    17.             requestList.add(oneTimeWorkRequest5)
    18.             requestList.add(oneTimeWorkRequest6)
    19.             WorkManager.getInstance().beginWith(requestList)
    20.                 .then(oneTimeWorkRequest4)
    21.                 .enque

    首先获取每个单任务事件，然后把3，5，6加到一个集合里面，beginWith意思是开始执行任务，then意思是然后再执行这个任务，想必执行顺序大家已经猜到了：

    1. E/多任务: work3 执行了
    2. E/多任务: work6 执行了
    3. E/多任务: work5 执行了
    4. E/多任务: work4 执行了

    注意：beginWith和then是有顺序的，集合里面执行并不是按照加入顺序执行。

    周期性任务（重点）

    我们经常会接到类似这样的的需求：每隔一天上传一次日志，看起来很简单，但是实现起来却异常困难！Google应该也考虑到了这样的场景，于是在WorkManager里面加入了周期性支持！这样的话我们的代码逻辑就会非常优雅。

    1.         val btn4 = findViewById
    2.         btn4.setOnClickListener {
    3.             val periodicWorkRequest =
    4.                 PeriodicWorkRequest
    5.                     .Builder(
    6.                         LzyWorkManager2::class.java,
    7.                         10,
    8.                         TimeUnit.SECONDS
    9.                     )
    10.                     .build()
    11.             WorkManager.getInstance().enqueue(periodicWorkRequest)
    12.         }

    注意：周期性任务最少15min一次，如果设置小于15min，按15分钟一次执行。 

    原理篇

    我们只关注主线流程，注意下面的代码：

    WorkManager.getInstance().enqueue(oneTimeWorkRequest)

    这个流程可以拆解成两个部分，先来看第一部分：

    1.     @Deprecated
    2.     public static @NonNull WorkManager getInstance() {
    3.         WorkManager workManager = WorkManagerImpl.getInstance();
    4.         if (workManager == null) {
    5.             throw new IllegalStateException("WorkManager is not initialized properly.  The most "
    6.                     + "likely cause is that you disabled WorkManagerInitializer in your manifest "
    7.                     + "but forgot to call WorkManager#initialize in your Application#onCreate or a "
    8.                     + "ContentProvider.");
    9.         } else {
    10.             return workManager;
    11.         }
    12.     }

    我们发现里面调用了WorkManagerImpl的getInstance方法，暂且先不进去看。按照单例的常规思维，如果为null，初始化。但是发现没有，直接抛出一个异常（英文不好的自行翻译）：

    1. WorkManager is not initialized properly.
    2.  The most likely cause is that you disabled WorkManagerInitializer 
    3. in your manifest but forgot to call 
    4. WorkManager#initialize in your 
    5. Application#onCreate or a ContentProvider.

    说明这个方法只是获取的而并非初始化的，那么初始化是在什么地方呢？

    我们点击生成的apk文件：

    进AndroidManifest.xml查看，注意这个provider：

    1.         <provider
    2.             android:name="androidx.startup.InitializationProvider"
    3.             android:exported="false"
    4.             android:authorities="com.example.workmanagertest.androidx-startup">
    5.  
    6.             <meta-data
    7.                 android:name="androidx.work.WorkManagerInitializer"
    8.                 android:value="androidx.startup" />
    9.         provider>

    点进去看一看：

    1. public final class WorkManagerInitializer implements Initializer {
    2.  
    3.     private static final String TAG = Logger.tagWithPrefix("WrkMgrInitializer");
    4.  
    5.     @NonNull
    6.     @Override
    7.     public WorkManager create(@NonNull Context context) {
    8.         // Initialize WorkManager with the default configuration.
    9.         Logger.get().debug(TAG, "Initializing WorkManager with default configuration.");
    10.         WorkManager.initialize(context, new Configuration.Builder().build());
    11.         return WorkManager.getInstance(context);
    12.     }
    13.  
    14.     @NonNull
    15.     @Override
    16.     public Listextends androidx.startup.Initializer>> dependencies() {
    17.         return Collections.emptyList();
    18.     }
    19. }

    很明显了，初始化是在ContentProvider里面进行的。进初始化方法看下：

    1. public static void initialize(@NonNull Context context, 
    2. @NonNull Configuration configuration) {
    3.         WorkManagerImpl.initialize(context, configuration);
    4. }

    前面我们讲了，获取WorkManager是通过WorkManagerImpl进行的，初始化同样也是。

    1. @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    2.     public static void initialize(@NonNull Context context, @NonNull Configuration configuration) {
    3.         synchronized (sLock) {
    4.             if (sDelegatedInstance != null && sDefaultInstance != null) {
    5.                 throw new IllegalStateException("WorkManager is already initialized.  Did you "
    6.                         + "try to initialize it manually without disabling "
    7.                         + "WorkManagerInitializer? See "
    8.                         + "WorkManager#initialize(Context, Configuration) or the class level "
    9.                         + "Javadoc for more information.");
    10.             }
    11.  
    12.             if (sDelegatedInstance == null) {
    13.                 context = context.getApplicationContext();
    14.                 if (sDefaultInstance == null) {
    15.                     sDefaultInstance = new WorkManagerImpl(
    16.                             context,
    17.                             configuration,
    18.                             new WorkManagerTaskExecutor(configuration.getTaskExecutor()));
    19.                 }
    20.                 sDelegatedInstance = sDefaultInstance;
    21.             }
    22.         }
    23.     }

    进WorkManagerImpl构造看下，最终的构造函数如下：

    1. @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    2.     public WorkManagerImpl(
    3.             @NonNull Context context,
    4.             @NonNull Configuration configuration,
    5.             @NonNull TaskExecutor workTaskExecutor,
    6.             @NonNull WorkDatabase database) {
    7.         Context applicationContext = context.getApplicationContext();
    8.         Logger.setLogger(new Logger.LogcatLogger(configuration.getMinimumLoggingLevel()));
    9.         List schedulers =
    10.                 createSchedulers(applicationContext, configuration, workTaskExecutor);
    11.         Processor processor = new Processor(
    12.                 context,
    13.                 configuration,
    14.                 workTaskExecutor,
    15.                 database,
    16.                 schedulers);
    17.         internalInit(context, configuration, workTaskExecutor, database, schedulers, processor);
    18.     }

    我们注意两个点就够了：

    • 使用了database：WorkManager能保证任务一定会被执行，即使你的应用程序当前不在运行中，哪怕你的设备重启，任务仍然会在适当的时候被执行。这是因为WorkManager有自己的数据库，关于任务的所有信息和数据都保存在这个数据库中，因此，只要你的任务交给了WorkManager，哪怕你的应用程序彻底退出，或者设备重新启动，WorkManager依然能够保证完成你交给的任务。
    • 使用了schedulers
    1. @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    2.     @NonNull
    3.     public List createSchedulers(
    4.             @NonNull Context context,
    5.             @NonNull Configuration configuration,
    6.             @NonNull TaskExecutor taskExecutor) {
    7.  
    8.         return Arrays.asList(
    9.                 Schedulers.createBestAvailableBackgroundScheduler(context, this),
    10.                 // Specify the task executor directly here as this happens before internalInit.
    11.                 // GreedyScheduler creates ConstraintTrackers and controllers eagerly.
    12.                 new GreedyScheduler(context, configuration, taskExecutor, this));
    13.     }

    最终使用了贪婪调度器。

    再来分析第二步：

    1.     @NonNull
    2.     public final Operation enqueue(@NonNull WorkRequest workRequest) {
    3.         return enqueue(Collections.singletonList(workRequest));
    4.     }
    5.  
    6.     @NonNull
    7.     public abstract Operation enqueue(@NonNull 
    8. List requests);

    发现enqueue是一个抽象方法，我们去实现类WorkManagerImpl看看：

    1.     @Override
    2.     @NonNull
    3.     public Operation enqueue(
    4.             @NonNull List requests) {
    5.  
    6.         // This error is not being propagated as part of the Operation, as we want the
    7.         // app to crash during development. Having no workRequests is always a developer error.
    8.         if (requests.isEmpty()) {
    9.             throw new IllegalArgumentException(
    10.                     "enqueue needs at least one WorkRequest.");
    11.         }
    12.         return new WorkContinuationImpl(this, requests).enqueue();
    13.     }

    又交给了WorkContinuationImpl处理：构造方法里面传入了requests。

    1. rivate final Listextends WorkRequest> mWork;
    2.  
    3. public WorkContinuationImpl(
    4.             @NonNull WorkManagerImpl workManagerImpl,
    5.             @NonNull List work) {
    6.         this(
    7.                 workManagerImpl,
    8.                 null,
    9.                 ExistingWorkPolicy.KEEP,
    10.                 work,
    11.                 null);
    12.     }
    13.  
    14.  
    15.  
    16. public WorkContinuationImpl(@NonNull WorkManagerImpl workManagerImpl,
    17.             @Nullable String name,
    18.             @NonNull ExistingWorkPolicy existingWorkPolicy,
    19.             @NonNull List work,
    20.             @Nullable List parents) {
    21.         mWorkManagerImpl = workManagerImpl;
    22.         mName = name;
    23.         mExistingWorkPolicy = existingWorkPolicy;
    24.         mWork = work;
    25.         mParents = parents;
    26.         mIds = new ArrayList<>(mWork.size());
    27.         mAllIds = new ArrayList<>();
    28.         if (parents != null) {
    29.             for (WorkContinuationImpl parent : parents) {
    30.                 mAllIds.addAll(parent.mAllIds);
    31.             }
    32.         }
    33.         for (int i = 0; i < work.size(); i++) {
    34.             String id = work.get(i).getStringId();
    35.             mIds.add(id);
    36.             mAllIds.add(id);
    37.         }
    38.     }

    我们再来看看WorkContinuationImpl的enqueue方法：

    1.     @Override
    2.     public @NonNull Operation enqueue() {
    3.         // Only enqueue if not already enqueued.
    4.         if (!mEnqueued) {
    5.             // The runnable walks the hierarchy of the continuations
    6.             // and marks them enqueued using the markEnqueued() method, parent first.
    7.             EnqueueRunnable runnable = new EnqueueRunnable(this);
    8.             mWorkManagerImpl.getWorkTaskExecutor()
    9. .executeOnBackgroundThread(runnable);
    10.             mOperation = runnable.getOperation();
    11.         } else {
    12.             Logger.get().warning(TAG,
    13.                     String.format("Already enqueued work ids (%s)", TextUtils.join(", ", mIds)));
    14.         }
    15.         return mOperation;
    16.     }

    先来看EnqueueRunnable是个啥：

    1. public class EnqueueRunnable implements Runnable {
    2.  
    3.     private final WorkContinuationImpl mWorkContinuation;
    4.     private final OperationImpl mOperation;
    5.  
    6.     public EnqueueRunnable(@NonNull WorkContinuationImpl workContinuation) {
    7.         mWorkContinuation = workContinuation;
    8.         mOperation = new OperationImpl();
    9.     }
    10.  
    11.     @Override
    12.     public void run() {
    13.         try {
    14.             if (mWorkContinuation.hasCycles()) {
    15.                 throw new IllegalStateException(
    16.                         String.format("WorkContinuation has cycles (%s)", mWorkContinuation));
    17.             }
    18.             boolean needsScheduling = addToDatabase();
    19.             if (needsScheduling) {
    20.                 // Enable RescheduleReceiver, only when there are Worker's that need scheduling.
    21.                 final Context context =
    22.                         mWorkContinuation.getWorkManagerImpl().getApplicationContext();
    23.                 PackageManagerHelper.setComponentEnabled(context, RescheduleReceiver.class, true);
    24.                 scheduleWorkInBackground();
    25.             }
    26.             mOperation.setState(Operation.SUCCESS);
    27.         } catch (Throwable exception) {
    28.             mOperation.setState(new Operation.State.FAILURE(exception));
    29.         }
    30.     }
    31. ```
    32. }

    首先将任务相关的信息加到数据库里面持久化，然后关注scheduleWorkInBackground方法：

    1.     @VisibleForTesting
    2.     public void scheduleWorkInBackground() {
    3.         WorkManagerImpl workManager = mWorkContinuation.getWorkManagerImpl();
    4.         Schedulers.schedule(
    5.                 workManager.getConfiguration(),
    6.                 workManager.getWorkDatabase(),
    7.                 workManager.getSchedulers());
    8.     }
    1. public static void schedule(
    2.             @NonNull Configuration configuration,
    3.             @NonNull WorkDatabase workDatabase,
    4.             List schedulers) {
    5.         if (schedulers == null || schedulers.size() == 0) {
    6.             return;
    7.         }
    8.  
    9.         WorkSpecDao workSpecDao = workDatabase.workSpecDao();
    10.         List eligibleWorkSpecsForLimitedSlots;
    11.         List allEligibleWorkSpecs;
    12.  
    13.         workDatabase.beginTransaction();
    14.         try {
    15.             // Enqueued workSpecs when scheduling limits are applicable.
    16.             eligibleWorkSpecsForLimitedSlots = workSpecDao.getEligibleWorkForScheduling(
    17.                     configuration.getMaxSchedulerLimit());
    18.  
    19.             // Enqueued workSpecs when scheduling limits are NOT applicable.
    20.             allEligibleWorkSpecs = workSpecDao.getAllEligibleWorkSpecsForScheduling(
    21.                     MAX_GREEDY_SCHEDULER_LIMIT);
    22.  
    23.             if (eligibleWorkSpecsForLimitedSlots != null
    24.                     && eligibleWorkSpecsForLimitedSlots.size() > 0) {
    25.                 long now = System.currentTimeMillis();
    26.  
    27.                 // Mark all the WorkSpecs as scheduled.
    28.                 // Calls to Scheduler#schedule() could potentially result in more schedules
    29.                 // on a separate thread. Therefore, this needs to be done first.
    30.                 for (WorkSpec workSpec : eligibleWorkSpecsForLimitedSlots) {
    31.                     workSpecDao.markWorkSpecScheduled(workSpec.id, now);
    32.                 }
    33.             }
    34.             workDatabase.setTransactionSuccessful();
    35.         } finally {
    36.             workDatabase.endTransaction();
    37.         }
    38.  
    39.         if (eligibleWorkSpecsForLimitedSlots != null
    40.                 && eligibleWorkSpecsForLimitedSlots.size() > 0) {
    41.  
    42.             WorkSpec[] eligibleWorkSpecsArray =
    43.                     new WorkSpec[eligibleWorkSpecsForLimitedSlots.size()];
    44.             eligibleWorkSpecsArray =
    45.                     eligibleWorkSpecsForLimitedSlots.toArray(eligibleWorkSpecsArray);
    46.  
    47.             // Delegate to the underlying schedulers.
    48.             for (Scheduler scheduler : schedulers) {
    49.                 if (scheduler.hasLimitedSchedulingSlots()) {
    50.                     scheduler.schedule(eligibleWorkSpecsArray);//1
    51.                 }
    52.             }
    53.         }
    54.  
    55.         if (allEligibleWorkSpecs != null && allEligibleWorkSpecs.size() > 0) {
    56.             WorkSpec[] enqueuedWorkSpecsArray = new WorkSpec[allEligibleWorkSpecs.size()];
    57.             enqueuedWorkSpecsArray = allEligibleWorkSpecs.toArray(enqueuedWorkSpecsArray);
    58.             // Delegate to the underlying schedulers.
    59.             for (Scheduler scheduler : schedulers) {
    60.                 if (!scheduler.hasLimitedSchedulingSlots()) {
    61.                     scheduler.schedule(enqueuedWorkSpecsArray);
    62.                 }
    63.             }
    64.         }
    65.     }

    首先将一些配置持久化到数据库里面，我们注释1处：

    最终调用的是初始化的时候初始化好的贪婪调度器的schedule方法：

    1. @Override
    2.     public void schedule(@NonNull WorkSpec... workSpecs) {
    3.         if (mInDefaultProcess == null) {
    4.             checkDefaultProcess();
    5.         }
    6.  
    7.         if (!mInDefaultProcess) {
    8.             Logger.get().info(TAG, "Ignoring schedule request in a secondary process");
    9.             return;
    10.         }
    11.  
    12.         registerExecutionListenerIfNeeded();
    13.  
    14.         // Keep track of the list of new WorkSpecs whose constraints need to be tracked.
    15.         // Add them to the known list of constrained WorkSpecs and call replace() on
    16.         // WorkConstraintsTracker. That way we only need to synchronize on the part where we
    17.         // are updating mConstrainedWorkSpecs.
    18.         Set constrainedWorkSpecs = new HashSet<>();
    19.         Set constrainedWorkSpecIds = new HashSet<>();
    20.  
    21.         for (WorkSpec workSpec : workSpecs) {
    22.             long nextRunTime = workSpec.calculateNextRunTime();
    23.             long now = System.currentTimeMillis();
    24.             if (workSpec.state == WorkInfo.State.ENQUEUED) {
    25.                 if (now < nextRunTime) {
    26.                     // Future work
    27.                     if (mDelayedWorkTracker != null) {
    28.                         mDelayedWorkTracker.schedule(workSpec);
    29.                     }
    30.                 } else if (workSpec.hasConstraints()) {
    31.                     if (SDK_INT >= 23 && workSpec.constraints.requiresDeviceIdle()) {
    32.                         // Ignore requests that have an idle mode constraint.
    33.                         Logger.get().debug(TAG,
    34.                                 String.format("Ignoring WorkSpec %s, Requires device idle.",
    35.                                         workSpec));
    36.                     } else if (SDK_INT >= 24 && workSpec.constraints.hasContentUriTriggers()) {
    37.                         // Ignore requests that have content uri triggers.
    38.                         Logger.get().debug(TAG,
    39.                                 String.format("Ignoring WorkSpec %s, Requires ContentUri triggers.",
    40.                                         workSpec));
    41.                     } else {
    42.                         constrainedWorkSpecs.add(workSpec);
    43.                         constrainedWorkSpecIds.add(workSpec.id);
    44.                     }
    45.                 } else {
    46.                     Logger.get().debug(TAG, String.format("Starting work for %s", workSpec.id));
    47.                     mWorkManagerImpl.startWork(workSpec.id);//1
    48.                 }
    49.             }
    50.         }
    51.  
    52.         // onExecuted() which is called on the main thread also modifies the list of mConstrained
    53.         // WorkSpecs. Therefore we need to lock here.
    54.         synchronized (mLock) {
    55.             if (!constrainedWorkSpecs.isEmpty()) {
    56.                 Logger.get().debug(TAG, String.format("Starting tracking for [%s]",
    57.                         TextUtils.join(",", constrainedWorkSpecIds)));
    58.                 mConstrainedWorkSpecs.addAll(constrainedWorkSpecs);
    59.                 mWorkConstraintsTracker.replace(mConstrainedWorkSpecs);
    60.             }
    61.         }
    62.     }

    如果没有约束，走注释1处：

    又回到了WorkManagerImpl里面：

    1.     @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    2.     public void startWork(@NonNull String workSpecId) {
    3.         startWork(workSpecId, null);
    4.     }
    5.  
    6.     @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    7.     public void startWork(
    8.             @NonNull String workSpecId,
    9.             @Nullable WorkerParameters.RuntimeExtras runtimeExtras) {
    10.         mWorkTaskExecutor
    11.                 .executeOnBackgroundThread(
    12.                         new StartWorkRunnable(this, workSpecId, runtimeExtras));
    13.     }
    14.  
    15.     
    16.

    很明显，这是一个线程池，进StartWorkRunable方法里面看看：

    1. @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    2. public class StartWorkRunnable implements Runnable {
    3.  
    4.     private WorkManagerImpl mWorkManagerImpl;
    5.     private String mWorkSpecId;
    6.     private WorkerParameters.RuntimeExtras mRuntimeExtras;
    7.  
    8.     public StartWorkRunnable(
    9.             WorkManagerImpl workManagerImpl,
    10.             String workSpecId,
    11.             WorkerParameters.RuntimeExtras runtimeExtras) {
    12.         mWorkManagerImpl = workManagerImpl;
    13.         mWorkSpecId = workSpecId;
    14.         mRuntimeExtras = runtimeExtras;
    15.     }
    16.  
    17.     @Override
    18.     public void run() {
    19.         mWorkManagerImpl.getProcessor().startWork(mWorkSpecId, mRuntimeExtras);
    20.     }
    21. }

    继续看Process的startWork：

    1. public boolean startWork(
    2.             @NonNull String id,
    3.             @Nullable WorkerParameters.RuntimeExtras runtimeExtras) {
    4.  
    5.         WorkerWrapper workWrapper;
    6.         synchronized (mLock) {
    7.             // Work may get triggered multiple times if they have passing constraints
    8.             // and new work with those constraints are added.
    9.             if (isEnqueued(id)) {
    10.                 Logger.get().debug(
    11.                         TAG,
    12.                         String.format("Work %s is already enqueued for processing", id));
    13.                 return false;
    14.             }
    15.  
    16.             workWrapper =
    17.                     new WorkerWrapper.Builder(
    18.                             mAppContext,
    19.                             mConfiguration,
    20.                             mWorkTaskExecutor,
    21.                             this,
    22.                             mWorkDatabase,
    23.                             id)
    24.                             .withSchedulers(mSchedulers)
    25.                             .withRuntimeExtras(runtimeExtras)
    26.                             .build();
    27.             ListenableFuture future = workWrapper.getFuture();
    28.             future.addListener(
    29.                     new FutureListener(this, id, future),
    30.                     mWorkTaskExecutor.getMainThreadExecutor());
    31.             mEnqueuedWorkMap.put(id, workWrapper);
    32.         }
    33.         mWorkTaskExecutor.getBackgroundExecutor().execute(workWrapper);//1
    34.         Logger.get().debug(TAG, String.format("%s: processing %s", getClass().getSimpleName(), id));
    35.         return true;
    36.     }

    将其封装成workWrapper，并执行execute方法：我们猜想workWrapper也是一个runnable！

    1. public class WorkerWrapper implements Runnable {
    2.  
    3. ```
    4.     
    5.     @WorkerThread
    6.     @Override
    7.     public void run() {
    8.         mTags = mWorkTagDao.getTagsForWorkSpecId(mWorkSpecId);
    9.         mWorkDescription = createWorkDescription(mTags);
    10.         runWorker();
    11.     }
    12.  
    13.     private void runWorker() {
    14.  
    15.         ···
    16.         runExpedited.addListener(new Runnable() {
    17.                 @Override
    18.                 public void run() {
    19.                     try {
    20.                         runExpedited.get();
    21.                         Logger.get().debug(TAG,
    22.                                 String.format("Starting work for %s", mWorkSpec.workerClassName));
    23.                         // Call mWorker.startWork() on the main thread.
    24.                         mInnerFuture = mWorker.startWork();//1
    25.                         future.setFuture(mInnerFuture);
    26.                     } catch (Throwable e) {
    27.                         future.setException(e);
    28.                     }
    29.                 }
    30.             }, mWorkTaskExecutor.getMainThreadExecutor());
    31. ···
    32.     }
    33.  
    34. ```
    35.  
    36. }

    关注注释1处：

    1. public abstract class ListenableWorker {
    2.  
    3. ```
    4.     @MainThread
    5.     public abstract @NonNull ListenableFuture startWork();
    6. ```
    7.  
    8. }

    而Worker又是实现了ListenableWorker：

    1.     @Override
    2.     public final @NonNull ListenableFuture startWork() {
    3.         mFuture = SettableFuture.create();
    4.         getBackgroundExecutor().execute(new Runnable() {
    5.             @Override
    6.             public void run() {
    7.                 try {
    8.                     Result result = doWork();//happy
    9.                     mFuture.set(result);
    10.                 } catch (Throwable throwable) {
    11.                     mFuture.setException(throwable);
    12.                 }
    13.  
    14.             }
    15.         });
    16.         return mFuture;
    17.     }

    Wow，终于我们熟悉的doWork出来了！

    一张图总结一下流程吧：

     关于WorkManager的线程池设计也非常有意思，有时间会单独写一篇文章详细聊聊！

  • 相关阅读:
    code:-9907磁盘不足如何处理？帮你整理了几个必备的！
    基于SSH开发美食网系统网站+论文+PPT+开题报告+任务书+外文翻译 毕业设计
    我对《RAG/大模型/非结构化数据知识库类产品》技术架构的思考、杂谈
    JavaBean专项练习(学生信息管理系统)(增删改查)(每步详细解释和思路)
    安卓常见设计模式13------过滤器模式（Kotlin版）
    CF1703G Good Key, Bad Key
    3.81 OrCAD软件绘制原理图时如何使用任意角度的走线？OrCAD软件怎么统一查看哪些元器件是没有PCB封装的？
    【业务功能篇105】 微服务-springcloud-springboot-电商订单模块--秒杀服务-定时任务【上篇】
    Vue开发实战二十二：列表中表格动态合并的实现
    HDFS集成Kerberos并使用Python调用
  • 原文地址：https://blog.csdn.net/qq_36428821/article/details/126317993