如何在WorkManager中处理异步任务详解

前言

workmanager 是 android jetpack 中的新组件，用于负责管理后台任务。关于这个组件的介绍就不多说了，网上到处都是，这里分享一下在 workmanager 中处理异步任务的方法。

我们知道，在 workmanager 中，处理任务的方式是创建一个继承自 worker 的任务类，实现 dowork() 方法，并在这个方法中实现我们自己的任务，然后返回 result.success() 或 result.failure() 来表示任务执行成功或者失败。在这里， dowork() 方法中的任务应该是同步的，这是很自然的，因为 dowork() 方法本身就是在子线程中执行，因此可以在 dowork() 方法中同步执行耗时操作。

但是些情况，我们想要执行的是异步任务，在 workmanager 中，有两种比较好的处理异步任务的方案。

rxworker

很多时候我们会使用 rxjava 来处理数据。幸运的是，我们可以使用 rxworker 来处理异步任务。

dependencies {
 ...
 implementation "android.arch.work:work-runtime:1.0.0-beta05"
 implementation "android.arch.work:work-rxjava2:1.0.0-beta05"
}

然后，将之前集成 work 的类改为继承 rxworker ，然后实现 creatework() 方法，基本结构如下：

public class asyncworker extends rxworker {

 public asyncworker(context appcontext, workerparameters workerparams) {
  super(appcontext, workerparams);
 }

 @override
 public single<result> creatework() {
  return remoteservice.getmysingleresponse()
    .doonsuccess(new consumer() {
     @override
     public void accept(object object) throws exception {
      // 处理任务
     }
    })
    .map(new function() {
     @override
     public object apply(object object) throws exception {
      return result.success();
     }
    })
    .onerrorreturn(new function() {
     @override
     public object apply(object object) throws exception {
      return result.failure();
     }
    });
 }
}

很简单是吧？有一点要注意的是， creatework() 方法默认是在主线程中执行的，如果 10 分钟没有结束任务，就会自动取消。

listenableworker

当我们去查看 rxworker 的源码时，就可以发现它是继承了 listenableworker 类，其实 worker 也是通过继承 listenableworker 实现的。 因此，我们可以通过自定义 listenableworker 来实现相同的功能。

看一下 worker 的源码，很简单：

public abstract class worker extends listenableworker {
 settablefuture<result> mfuture;
 public worker(@nonnull context context, @nonnull workerparameters workerparams) {
  super(context, workerparams);
 }

 @workerthread
 public abstract @nonnull result dowork();
 @override
 public final @nonnull listenablefuture<result> startwork() {
  mfuture = settablefuture.create();
  getbackgroundexecutor().execute(new runnable() {
   @override
   public void run() {
    result result = dowork();
    mfuture.set(result);
   }
  });
  return mfuture;
 }
}

可以里面主要使用了 settablefuture 这个类，在 startwork() 里面先创建了 settablefuture 对象，然后开了一个子线程，在子线程里面执行 dowork() 方法，完了就使用 mfuture.set() 方法将 result 返回。

因此我们也可以模仿 worker 类的写法，来实现自己的异步处理，简单地模板代码如下：

public class asyncworker extends listenableworker {
 private settablefuture<result> mfuture;
 public asyncworker(context appcontext,workerparameters workerparams) {
  super(appcontext, workerparams);
 }

 @override
 public listenablefuture<result> startwork() {
  mfuture = settablefuture.create();
  dosomeasyncwork(new asynclistener() {
   @override
   public void success() {
    mfuture.set(result.success());
   }
   
   @override
   public void fail() {
    mfuture.set(result.failure());
   }
  });
  return mfuture;
 }
}

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。