前言

Android中执行后台任务有JobScheduler、Loader、Service等方案 ，WorkManager的出现用来替换以上所有的 Android 后台任务方案，为后台任务提供了一套统一的解决方案，保证了api的一致性和稳定性，同时谷歌在开发WorkManager时也考虑到后台任务对电池续航的影响。WorkManager 能保证任务一定会执行，即使用户导航离开屏幕、退出应用或重启设备也不影响。

基本使用

使用 WorkManager 需要继承 Worker 类，后台任务在doWork() 方法中实现

doWork() 方法的返回值Resutl有三种类型：

• Result.success()：执行成功。
• Result.failure()：执行失败。
• Result.retry()：执行失败，重试。

class MainWorker (context: Context, workerParameters: WorkerParameters) : Worker(context, workerParameters) {

    companion object { const val TAG = "MainWorker" }

    @SuppressLint("RestrictedApi")
    override fun doWork(): Result {
        Log.d(TAG, "MainWorker doWork: 后台任务执行了")
        return Result.Success() // doWork成功 执行任务完毕
    }
}

定义任务后，可以使用Constraints设置约束条件，例如定义手机必须联网、必须在充电中、必须是空闲时才执行该后台任务，最后须用 WorkManager 进行调度该任务才能运行。更多进阶使用可以看这里。

    fun testBackgroundWork(view: View?) {
        //设置约束条件
        val constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED) // 必须是联网中
            .setRequiresCharging(true) // 必须是充电中
            .setRequiresDeviceIdle(true) // 必须是空闲时
            .build()

        // 请求对象
        val request = OneTimeWorkRequest.Builder(MainWorker::class.java)
            .setConstraints(constraints) // Request 关联 约束条件
            .build()

        // 加入队列
        WorkManager.getInstance(this).enqueue(request)
    }

源码

1.初始化

上面例子中是通过WorkManager.getInstance获得单例对象，然后再执行后台任务，看一下这个方法的源码。

    public static @NonNull WorkManagerImpl getInstance(@NonNull Context context) {
        synchronized (sLock) {
            WorkManagerImpl instance = getInstance();//这里不为空，直接返回
            if (instance == null) {
                Context appContext = context.getApplicationContext();
                if (appContext instanceof Configuration.Provider) {
                    initialize(
                            appContext,
                            ((Configuration.Provider) appContext).getWorkManagerConfiguration());
                    instance = getInstance(appContext);
                } else {
                    throw new IllegalStateException("WorkManager is not initialized properly.  You "
                            + "have explicitly disabled WorkManagerInitializer in your manifest, "
                            + "have not manually called WorkManager#initialize at this point, and "
                            + "your Application does not implement Configuration.Provider.");
                }
            }

            return instance;
        }
    }

getInstance方法会调用到WorkManager的实现类WorkManagerImpl中，默认情况下这里第一行代码其实会直接返回，因为getInstance不为空，初始化工作在app启动时就通过ContentProvider完成了。

 <provider
      android:name="androidx.work.impl.WorkManagerInitializer"
      android:exported="false"
      android:multiprocess="true"
      android:authorities="com.derry.workmanager.workmanager-init"
      android:directBootAware="false" />

public class WorkManagerInitializer extends ContentProvider {
    @Override
    public boolean onCreate() {
        // Initialize WorkManager with the default configuration.
        WorkManager.initialize(getContext(), new Configuration.Builder().build());
        return true;
    }
}

找到编译后的build文件夹中的apk，查看其清单文件可以发现注册了一个provider，这个类的onCreate方法中就调用了WorkManager的初始化方法，我们知道ContentProvider在Application生命周期方法onCreate之前就会初始化，所以WorkManager也在这时就被初始化了。

    public static void initialize(@NonNull Context context, @NonNull Configuration configuration) {
        synchronized (sLock) {
            ...
            if (sDelegatedInstance == null) {
                context = context.getApplicationContext();
                if (sDefaultInstance == null) {
                    sDefaultInstance = new WorkManagerImpl(
                            context,
                            configuration,
                            new WorkManagerTaskExecutor(configuration.getTaskExecutor()));
                }
                sDelegatedInstance = sDefaultInstance;
            }
        }
    }

initialize方法里，configuration.getTaskExecutor()内部返回一个固定线程数量的线程池，创建WorkManagerTaskExecutor用来执行线程池的任务，然后调用WorkManagerImpl的构造方法。

    public WorkManagerImpl(
            @NonNull Context context,
            @NonNull Configuration configuration,
            @NonNull TaskExecutor workTaskExecutor,
            @NonNull WorkDatabase database) {
        Context applicationContext = context.getApplicationContext();
        Logger.setLogger(new Logger.LogcatLogger(configuration.getMinimumLoggingLevel()));
        List<Scheduler> schedulers = createSchedulers(applicationContext, workTaskExecutor);
        Processor processor = new Processor(
                context,
                configuration,
                workTaskExecutor,
                database,
                schedulers);
        internalInit(context, configuration, workTaskExecutor, database, schedulers, processor);
    }

WorkManagerImpl构造方法中做了以下几件事

1.创建了Room数据库，Room也是对sqlite的再封装，数据库用来记录每一个后台任务的信息，包括执行顺序 、执行时间等信息；

2.创建schedulers调度器，主要有三种GreedyScheduler、SystemAlarmScheduler、SystemJobScheduler，根据系统版本来选择用哪种；

3.创建Processor处理器，Processor用来管理Schedulers的执行，启动或停止任务；

2.任务入队方法enqueue

 进入WorkManagerImpl.enqueue方法，创建一个WorkContinuationImpl对象执行enqueue方法。

    public Operation enqueue(
            @NonNull List<? extends WorkRequest> workRequests) {

        // This error is not being propagated as part of the Operation, as we want the
        // app to crash during development. Having no workRequests is always a developer error.
        if (workRequests.isEmpty()) {
            throw new IllegalArgumentException(
                    "enqueue needs at least one WorkRequest.");
        }
        return new WorkContinuationImpl(this, workRequests).enqueue();
    }

WorkContinuationImpl.enqueue方法，创建EnqueueRunnable并在后台线程池中执行

    public @NonNull Operation enqueue() {
        if (!mEnqueued) {
            EnqueueRunnable runnable = new EnqueueRunnable(this);
            mWorkManagerImpl.getWorkTaskExecutor().executeOnBackgroundThread(runnable);
            mOperation = runnable.getOperation();
        } else {
            Logger.get().warning(TAG,
                    String.format("Already enqueued work ids (%s)", TextUtils.join(", ", mIds)));
        }
        return mOperation;
    }

EnqueueRunnable.run方法，将workSpec添加到数据库并对任务状态进行校验，将RescheduleReceiver注册到AndroidManifest.xml内，在scheduleWorkInBackground方法中执行调度工作

    public void run() {
        try {
            if (mWorkContinuation.hasCycles()) {
                throw new IllegalStateException(
                        String.format("WorkContinuation has cycles (%s)", mWorkContinuation));
            }
            //将任务信息添加到数据库
            boolean needsScheduling = addToDatabase();
            if (needsScheduling) {
                //启用 RescheduleReceiver，仅当有需要调度的Worker时。
                final Context context =
                        mWorkContinuation.getWorkManagerImpl().getApplicationContext();
                //允许将RescheduleReceiver注册到AndroidManifest.xml内
                PackageManagerHelper.setComponentEnabled(context, RescheduleReceiver.class, true);
                scheduleWorkInBackground();
            }
            mOperation.setState(Operation.SUCCESS);
        } catch (Throwable exception) {
            mOperation.setState(new Operation.State.FAILURE(exception));
        }
    }

3.Schedulers调度器

EnqueueRunnable. scheduleWorkInBackground方法，调用了Schedulers.schedule方法，传入了Configuration, WorkDatabase, Schedulers三个对象

    public void scheduleWorkInBackground() {
        WorkManagerImpl workManager = mWorkContinuation.getWorkManagerImpl();
        Schedulers.schedule(
                workManager.getConfiguration(),
                workManager.getWorkDatabase(),
                workManager.getSchedulers());
    }

Schedulers.schedule方法，先进行了一系列的数据库操作，主要是查询数据库中未执行的任务，然后根据条件对每个任务进行调度。Schedulers将任务交给每一个Scheduler去处理，GreedyScheduler会先处理这个任务。

    public static void schedule(
            @NonNull Configuration configuration,
            @NonNull WorkDatabase workDatabase,
            List<Scheduler> schedulers) {
        List<WorkSpec> eligibleWorkSpecs;
        ...
        if (eligibleWorkSpecs != null && eligibleWorkSpecs.size() > 0) {
            WorkSpec[] eligibleWorkSpecsArray = eligibleWorkSpecs.toArray(new WorkSpec[0]);
            // 交给底层调度器去调度
            for (Scheduler scheduler : schedulers) {
                scheduler.schedule(eligibleWorkSpecsArray);
            }
        }
    }

GreedyScheduler类，判断是否有约束条件，有则将任务入集合，没有则调用startWork方法。假如有低电量的约束条件，则会在清单文件生成名为BatteryNotLowProxy的receiver，实现原理就是通过监听约束条件变化的广播，然后通过一系列处理，最后也是调用到startWork方法，其他约束条件也是大同小异。

    public void schedule(@NonNull WorkSpec... workSpecs) {
        ...
        for (WorkSpec workSpec : workSpecs) {
            if (workSpec.state == WorkInfo.State.ENQUEUED
                    && !workSpec.isPeriodic()
                    && workSpec.initialDelay == 0L
                    && !workSpec.isBackedOff()) {
                
                if (workSpec.hasConstraints()) {
                    ...
                    //有约束条件
                    constrainedWorkSpecs.add(workSpec);
                    constrainedWorkSpecIds.add(workSpec.id);
                } else {
                    //无约束条件
                    mWorkManagerImpl.startWork(workSpec.id);
                }
            }
        }
        ...
    }

WorkManagerImpl.startWork方法，WorkTaskExecutor执行了Runnnable，下面进入 StartWorkRunnable的run()的实现

    public void startWork(
            @NonNull String workSpecId,
            @Nullable WorkerParameters.RuntimeExtras runtimeExtras) {
        mWorkTaskExecutor
                .executeOnBackgroundThread(
                        new StartWorkRunnable(this, workSpecId, runtimeExtras));
    }

 StartWorkRunnable.run方法，将任务的信息交给Processor，由Processor调用startWork()去执行任务

    public void run() {
        mWorkManagerImpl.getProcessor().startWork(mWorkSpecId, mRuntimeExtras);
    }

4.Processor处理器

processor处理器可以智能地按需安排和执行后台任务

processor.startWork方法，这里会将任务包装成一个WorkWrapper，WorkWrapper也是一个Runnable，然后再次调用WorkTaskExecutor执行Runnnable。

    public boolean startWork(@NonNull String id,@Nullable WorkerParameters.RuntimeExtras runtimeExtras) {

        WorkerWrapper workWrapper;
        synchronized (mLock) {
            ...
            workWrapper =
                    new WorkerWrapper.Builder(
                            mAppContext,
                            mConfiguration,
                            mWorkTaskExecutor,
                            this,
                            mWorkDatabase,
                            id)
                            .withSchedulers(mSchedulers)
                            .withRuntimeExtras(runtimeExtras)
                            .build();
            ListenableFuture<Boolean> future = workWrapper.getFuture();
            future.addListener(
                    new FutureListener(this, id, future),
                    mWorkTaskExecutor.getMainThreadExecutor());
            mEnqueuedWorkMap.put(id, workWrapper);
        }
        //执行Ruunable
        mWorkTaskExecutor.getBackgroundExecutor().execute(workWrapper);
        return true;
    }

WorkWrapper类的run方法，通过反射获取到ListenableWorker对象也就是Worker类的父类，然后调用ListenableWorker.startWork方法，也就是调用Worker类的startWork方法。

    public void run() {
        mTags = mWorkTagDao.getTagsForWorkSpecId(mWorkSpecId);
        mWorkDescription = createWorkDescription(mTags);
        runWorker();
    }

    private void runWorker() {
        ...
        //反射获取ListenableWorker对象
        if (mWorker == null) {
            mWorker = mConfiguration.getWorkerFactory().createWorkerWithDefaultFallback(
                    mAppContext,
                    mWorkSpec.workerClassName,
                    params);
        }
        if (trySetRunning()) {
            if (tryCheckForInterruptionAndResolve()) {
                return;
            }

            final SettableFuture<ListenableWorker.Result> future = SettableFuture.create();
            
            mWorkTaskExecutor.getMainThreadExecutor()
                    .execute(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                Logger.get().debug(TAG, String.format("Starting work for %s",
                                        mWorkSpec.workerClassName));
                                //这里调用startWork方法
                                mInnerFuture = mWorker.startWork();
                                future.setFuture(mInnerFuture);
                            } catch (Throwable e) {
                                future.setException(e);
                            }

                        }
                    });
    }

Worker.startWork方法，这里即调用到我们自己实现的doWork方法，至此整个流程结束。

    public abstract @NonNull Result doWork();

    public final @NonNull ListenableFuture<Result> startWork() {
        mFuture = SettableFuture.create();
        getBackgroundExecutor().execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Result result = doWork();
                    mFuture.set(result);
                } catch (Throwable throwable) {
                    mFuture.setException(throwable);
                }

            }
        });
        return mFuture;
    }

小结

WorkManager是一个很优秀的框架使用方法也很简单，适用于可延迟执行的任务，即使应用程序或设备重新启动也能保证一定会执行。WorkManager会针对不同Android版本的选择不同的执行策略，所以可以的话推荐使用WorkManager替代原有的方案。

以上不足之处请指正，欢迎留言，谢谢。