| Android几种定时任务实现方式汇总 | 您所在的位置：网站首页 › 定时任务实现方式怎么设置 › Android几种定时任务实现方式汇总 |
Android几种定时任务实现方式汇总
|
目录 前言 方式一：AlarmManager API19之前AlarmManager常用的一些方法 参数说明 使用举例 AlarmManager实例Demo讲解（包含版本适配以及高版本设置重复闹钟） AlarmManager总结 方式二：Handler实现方式 采用Handle与线程的sleep(long)方法 采用Handler的postDelayed(Runnable, long)方法 采用Handler与timer及TimerTask结合的方法 方式三：ScheduledExecutorService 延迟不循环任务schedule方法 方式三：RXjava实现 方式四：WorkManager实现定时任务 方式五：安卓协程实现定时任务 主要特性 基本用法 注意事项 总结 前言Android开发当中，定时器的场景太多太多，比如过多久轮询一次业务需求，或者轮询网络以及多少秒的倒计时，记录一下给需要的人一些帮助 Android中的定时任务一般有两种实现方式，一种是使用 Java API 里提供的 Timer 类，一种是使用 Android 的 Alarm 机制。这两种方式在多数情况下都能实现类似的效果，但 Timer 有一个明显的短板，它并不适用于那些需要长期在后台运行的定时任务。我们都知道，为了能让电池更加耐用，每种手机都会有自己的休眠策略，Android 手机就会在长时间不操作的情况下自动让 CPU 进入到睡眠状态，这就有可能导致 Timer 中的定时任务无法正常运行。而 Alarm 则具有唤醒 CPU 的功能，它可以在需要执行定时任务的时候大吼一声：“小UU，不要跟我 bbll ，赶紧给我起来干活，不然你看我扎不扎你就完了。” 需要注意，这里唤醒 CPU 和唤醒屏幕完全不是一个概念，千万不要混淆。 方式一：AlarmManager API19之前AlarmManager常用的一些方法 set(int type，long startTime，PendingIntent pi) //该方法用于设置一次性定时器，到达时间执行完就GG了setRepeating(int type，long startTime，long intervalTime，PendingIntent pi)//该方法用于设置可重复执行的定时器setInexactRepeating（int type，long startTime，long intervalTime，PendingIntent pi）//该方法用于设置可重复执行的定时器。与setRepeating相比，这个方法更加考虑系统电量，比如系统在低电量情况下可能不会严格按照设定的间隔时间执行闹钟，因为系统可以调整报警的交付时间，使其同时触发，避免超过必要的唤醒设备。 参数说明int type：闹钟类型，常用有几个类型，说明如下： | | | |--|--| | AlarmManager.ELAPSED_REALTIME |表示闹钟在手机睡眠状态下不可用，就是睡眠状态下不具备唤醒CPU的能力（跟普通Timer差不多了），该状态下闹钟使用相对时间,相对于系统启动开始。 | |AlarmManager.ELAPSED_REALTIME_WAKEUP|表示闹钟在睡眠状态下会唤醒系统并执行提示功能，该状态下闹钟也使用相对时间| |AlarmManager.RTC|表示闹钟在睡眠状态下不可用，该状态下闹钟使用绝对时间，即当前系统时间| |AlarmManager.RTC_WAKEUP|表示闹钟在睡眠状态下会唤醒系统并执行提示功能，该状态下闹钟使用绝对时间| long startTime： 定时任务的出发时间，以毫秒为单位。 PendingIntent pi： 到时间后的执行意图。PendingIntent是Intent的封装类。需要注意的是，如果是通过启动服务来实现闹钟提 示的话，PendingIntent对象的获取就应该采用Pending.getService(Context c,int i,Intent intent,int j)方法；如果是通过广播来实现闹钟提示的话，PendingIntent对象的获取就应该采用 PendingIntent.getBroadcast(Context c,int i,Intent intent,int j)方法；如果是采用Activity的方式来实现闹钟提示的话，PendingIntent对象的获取就应该采用 PendingIntent.getActivity(Context c,int i,Intent intent,int j)方法。关于PendingInten不是本文重点，请自行查阅使用方法。 使用举例需求：定义一个在CPU休眠情况下也能执行的闹钟，到==指定时间==发送一次广播，代码如下： AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); Calendar calendar = Calendar.getInstance(); calendar.set(Calendar.HOUR_OF_DAY,21); calendar.set(Calendar.MINUTE,14); calendar.set(Calendar.SECOND,00);//这里代表 21.14.00 Intent intent = new Intent("Li_ALI"); intent.putExtra("msg","阿力起床了啊"); PendingIntent pi = PendingIntent.getBroadcast(this,0,intent,0); // 到了 21点14分00秒 后通过PendingIntent pi对象发送广播 am.set(AlarmManager.RTC_WAKEUP,calendar.getTimeInMillis(),pi); AlarmManager实例Demo讲解（包含版本适配以及高版本设置重复闹钟）好了经过上面讲解，我相信你是似懂非懂的，因为没看到具体代码啊，简单，一个小Demo就全都明白了。 实现功能：在CPU休眠情况下依然可以设定时间启动一次服务，在服务中执行相应逻辑(Demo中只是打印Log),适配各个版本。 先看一下最核心的AlarmManagerUtils类（AlarmManager工具类）： package com.shanya.testalarm; import android.annotation.SuppressLint; import android.app.AlarmManager; import android.app.PendingIntent; import android.content.Context; import android.content.Intent; import android.os.Build; import java.util.Calendar; public class AlarmManagerUtils { private static final long TIME_INTERVAL = 10 * 1000;//闹钟执行任务的时间间隔 private Context context; public static AlarmManager am; public static PendingIntent pendingIntent; private Calendar calendar; // private AlarmManagerUtils(Context aContext) { this.context = aContext; } //singleton private static AlarmManagerUtils instance = null; public static AlarmManagerUtils getInstance(Context aContext) { if (instance == null) { synchronized (AlarmManagerUtils.class) { if (instance == null) { instance = new AlarmManagerUtils(aContext); } } } return instance; } public void createGetUpAlarmManager() { am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); Intent intent = new Intent(context, MyService.class); pendingIntent = PendingIntent.getService(context, 0, intent, 0);//每隔10秒启动一次服务 } @SuppressLint("NewApi") public void getUpAlarmManagerStartWork() { calendar = Calendar.getInstance(); calendar.set(Calendar.HOUR_OF_DAY,23); calendar.set(Calendar.MINUTE,50); calendar.set(Calendar.SECOND,00); //版本适配 System.currentTimeMillis() if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {// 6.0及以上 am.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), pendingIntent); } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {// 4.4及以上 am.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), pendingIntent); } else { am.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), TIME_INTERVAL, pendingIntent); } } @SuppressLint("NewApi") public void getUpAlarmManagerWorkOnOthers() { //高版本重复设置闹钟达到低版本中setRepeating相同效果 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {// 6.0及以上 am.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + TIME_INTERVAL, pendingIntent); } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {// 4.4及以上 am.setExact(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + TIME_INTERVAL, pendingIntent); } } }AlarmManagerUtils就是将与AlarmManager有关的操作都封装起来了，方便解耦。很简单，主要就是版本适配了，上面已经讲解够仔细了，这里就是判断不同版本调用不同API了。 MainActivity代码： package com.shanya.testalarm; import androidx.appcompat.app.AppCompatActivity; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.Toast; public class MainActivity extends AppCompatActivity { private AlarmManagerUtils alarmManagerUtils; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); alarmManagerUtils = AlarmManagerUtils.getInstance(this); alarmManagerUtils.createGetUpAlarmManager(); Button button = findViewById(R.id.am); button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { alarmManagerUtils.getUpAlarmManagerStartWork(); Toast.makeText(getApplicationContext(),"设置成功",Toast.LENGTH_SHORT).show(); } }); } }MainActivity中就是调用AlarmManagerUtils中已经封装好的代码进行初始化以及点击Button的时候调用getUpAlarmManagerStartWork方法完成第一次触发AlarmManager。 最后看下服务类中具体做了什么。 MyService类： package com.shanya.testalarm; import android.app.AlarmManager; import android.app.PendingIntent; import android.app.Service; import android.content.Intent; import android.os.Build; import android.os.IBinder; import android.os.SystemClock; import android.util.Log; import android.widget.Toast; import androidx.annotation.RequiresApi; public class MyService extends Service { private static final String TAG = "MyService"; public MyService() { } @Override public IBinder onBind(Intent intent) { // TODO: Return the communication channel to the service. throw new UnsupportedOperationException("Not yet implemented"); } @RequiresApi(api = Build.VERSION_CODES.M) @Override public int onStartCommand(Intent intent, int flags, int startId) { new Thread(new Runnable() { @Override public void run() { Log.d(TAG, "run: "); } }).start(); AlarmManagerUtils.getInstance(getApplicationContext()).getUpAlarmManagerWorkOnOthers(); return super.onStartCommand(intent, flags, startId); } } AlarmManager总结好了，本文到此就该结束了，相信经过以上讲述你对AlarmManager有了更进一步全面了解，在我们使用的时候请不要滥用，考虑一下用户电量，尽量优化自己APP。 方式二：Handler实现方式 采用Handle与线程的sleep(long)方法Handler主要用来处理接受到的消息。这只是最主要的方法，当然Handler里还有其他的方法供实现，有兴趣的可以去查API，这里不过多解释。 1. 定义一个Handler类，用于处理接受到的Message。 Handler handler = new Handler(new Handler.Callback() { @Override public boolean handleMessage(@NonNull Message msg) { // 要做的事情 return false; } });2. 新建一个实现Runnable接口的线程类，如下： public class MyThread implements Runnable { @Override public void run() { // TODO Auto-generated method stub while (true) { try { Thread.sleep(10000);// 线程暂停10秒，单位毫秒 Message message = new Message(); message.what = 1; handler.sendMessage(message);// 发送消息 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }3. 在需要启动线程的地方加入下面语句： new Thread(new MyThread()).start();4. 启动线程后，线程每10s发送一次消息。 5.最后记得在onDestroy回收清空 采用Handler的postDelayed(Runnable, long)方法1. 定义一个Handler类 Handler handler=new Handler(); Runnable runnable=new Runnable() { @Override public void run() { // TODO Auto-generated method stub //要做的事情 handler.postDelayed(this, 2000); } };2. 启动计时器 handler.postDelayed(runnable, 2000);//每两秒执行一次runnable.3. 停止计时器 handler.removeCallbacks(runnable); 采用Handler与timer及TimerTask结合的方法1. 定义定时器、定时器任务及Handler句柄 private final Timer timer = new Timer(); private TimerTask task; Handler handler = new Handler() { @Override public void handleMessage(Message msg) { // TODO Auto-generated method stub // 要做的事情 super.handleMessage(msg); } };2. 初始化计时器任务 task = new TimerTask() { @Override public void run() { // TODO Auto-generated method stub Message message = new Message(); message.what = 1; handler.sendMessage(message); } };3. 启动定时器 timer.schedule(task, 2000, 2000);4. 停止计时器 timer.cancel(); 方式三：ScheduledExecutorService介绍： ScheduledExecutorService有线程池的特性，也可以实现任务循环执行，可以看作是一个简单地定时任务组件，因为有线程池特性，所以任务之间可以多线程并发执行，互不影响，当任务来的时候，才会真正创建线程去执行 我们在做一些普通定时循环任务时可以用它，比如定时刷新字典常量，只需要不断重复执行即可，这篇文章讲解一下它的用法以及注意事项，不涉及底层原理 注意：我们都知道，在使用线程池的时候，如果我们的任务出现异常没有捕获，那么线程会销毁被回收，不会影响其他任务继续提交并执行，但是在这里，如果你的任务出现异常没有捕获，会导致后续的任务不再执行，所以一定要try...catch 延迟不循环任务schedule方法schedule(Runnable command, long delay, TimeUnit unit) 参数1：任务 参数2：方法第一次执行的延迟时间 参数3：延迟单位 说明：延迟任务，只执行一次(不会再次执行)，参数2为延迟时间 案例说明： private ScheduledExecutorService mScheduledExecutorService; mScheduledExecutorService = Executors.newSingleThreadScheduledExecutor(); mScheduledExecutorService.scheduleAtFixedRate(() -> { try { //有网络的情况下合成播放 if (ConfigApp.isExtranet()) { syntheticConsumption(); } } catch (Exception e) { Timber.i("合成mScheduledExecutorService出错了!"); } }, 0, 1, TimeUnit.SECONDS); 方式三：RXjava实现rxjava实现方式需要导包，根据需要导入对应的包即可 //rxjava2 api 'io.reactivex.rxjava2:rxjava:2.2.19' api 'io.reactivex.rxjava2:rxandroid:2.1.1' api 'com.jakewharton.rxbinding2:rxbinding:2.2.0'工具类封装： package com.maxvision.fyj.common.utils; import android.content.Context; import androidx.annotation.NonNull; import com.maxvision.fyj.common.aop.CheckNetAspect; import org.jetbrains.annotations.NotNull; import java.util.concurrent.TimeUnit; import io.reactivex.Observable; import io.reactivex.Observer; import io.reactivex.android.schedulers.AndroidSchedulers; import io.reactivex.disposables.Disposable; import io.reactivex.schedulers.Schedulers; /** * name：cl * date：2022/8/16 * desc： */ public class RxTimer { private Disposable mDisposable; private Disposable mDisposable2; /** * milliseconds毫秒后执行指定动作 * * @param milliSeconds * @param rxAction */ public void timer(long milliSeconds, final RxAction rxAction) { Observable.timer(milliSeconds, TimeUnit.MILLISECONDS) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer() { @Override public void onSubscribe(@NonNull Disposable disposable) { mDisposable = disposable; } @Override public void onNext(@NonNull Long number) { if (rxAction != null) { rxAction.action(number); } } @Override public void onError(@NonNull Throwable e) { //取消订阅 cancel(); } @Override public void onComplete() { //取消订阅 cancel(); } }); } /** * 每隔milliseconds毫秒后执行指定动作 * * @param milliSeconds * @param rxAction */ public void interval(long milliSeconds, final RxAction rxAction) { Observable.interval(milliSeconds, TimeUnit.MILLISECONDS) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer() { @Override public void onSubscribe(@NonNull Disposable disposable) { mDisposable = disposable; } @Override public void onNext(@NonNull Long number) { if (rxAction != null) { rxAction.action(number); } } @Override public void onError(@NonNull Throwable e) { } @Override public void onComplete() { } }); } /** * 网络判断 */ public void networkCallback(Context context, RxNetwork rxNetwork) { Observable.just(CheckNetAspect.pingFactory(context)) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer() { @Override public void onSubscribe(@NotNull Disposable d) { mDisposable2 = d; } @Override public void onNext(@NotNull Boolean aBoolean) { rxNetwork.networkCB(aBoolean); } @Override public void onError(@NotNull Throwable e) { rxNetwork.networkCB(false); } @Override public void onComplete() { } }); } /** * 取消订阅 */ public void cancel() { if (mDisposable != null && !mDisposable.isDisposed()) { mDisposable.dispose(); } if (mDisposable2 != null && !mDisposable2.isDisposed()) { mDisposable2.dispose(); } } public interface RxAction { /** * 让调用者指定指定动作 * * @param number 时间 */ void action(long number); } public interface RxNetwork { void networkCB(boolean network); } }使用方法： rxTimer = new RxTimer(); rxTimer.interval(5000, number -> { LogUtils.e("MQTT","startMqtt==========="); }); //取消 rxTimer.cancel(); 方式四：WorkManager实现定时任务同样的如果不清楚WorkManager的基础使用，推荐大家看看教程 Android架构组件WorkManager详解 WorkManager的使用相对来说也比较简单， WorkManager组件库里面提供了一个专门做周期性任务的类PeriodicWorkRequest。但是PeriodicWorkRequest类有一个限制条件最小的周期时间是15分钟。 WorkManager 比较适合一些比较长时间的任务。还能设置一些约束条件，比如我们每24小时，在设备充电的时候我们就上传这一整天的Log文件到服务器，比如我们每隔12小时就检查应用是否需要更新，如果需要更新则自动下载安装（需要指定Root设备）。 场景如下，还是那个放在公司前台常亮并且一直运行在前台的平板，我们每12小时就检查自动更新，并自动安装，由于之前写了 AlarmManager 所以安装成功之后App会自动打开。 Data inputData2 = new Data.Builder().putString("version", "1.0.0").build(); PeriodicWorkRequest checkVersionRequest = new PeriodicWorkRequest.Builder(CheckVersionWork.class, 12, TimeUnit.HOURS) .setInputData(inputData2).build(); WorkManager.getInstance().enqueue(checkVersionRequest); WorkManager.getInstance().getWorkInfoByIdLiveData(checkVersionRequest.getId()).observe(this, workInfo -> { assert workInfo != null; WorkInfo.State state = workInfo.getState(); Data data = workInfo.getOutputData(); String url = data.getString("download_url", ""); //去下载并静默安装Apk downLoadingApkInstall(url) }); /** * 间隔12个小时的定时任务，检测版本的更新 */ public class CheckVersionWork extends Worker { public CheckVersionWork(@NonNull Context context, @NonNull WorkerParameters workerParams) { super(context, workerParams); } @Override public void onStopped() { super.onStopped(); } @NonNull @Override public Result doWork() { Data inputData = getInputData(); String version = inputData.getString("version"); //接口获取当前最新的信息 //对比当前版本与服务器版本，是否需要更新 //如果需要更新，返回更新下载的url Data outputData = new Data.Builder().putString("key_name", inputData.getString("download_url", "xxxxxx")).build(); //设置输出数据 setOutputData(outputData); return Result.success(); } }这个时间太长了不好测试，不过是我之前自用的代码，没什么问题，哪天有时间做个Demo把日志文件导出来看看才能看出效果。 那除此之外我们一些Log的上传，图片的更新，资源或插件的下载等，我们都可以通过WorkManager来实现一些后台的操作，使用起来也是很简单。 方式五：安卓协程实现定时任务Android 协程（Kotlin Coroutines）是一种轻量级的异步编程框架，用于简化并发编程和异步任务处理。协程在 Kotlin 中通过 kotlinx.coroutines 库实现，能够在不阻塞主线程的情况下执行后台任务，显著简化了复杂的异步代码。 主要特性 轻量级：与传统线程相比，协程开销更小，可以高效地管理成千上万个并发任务。结构化并发：协程提供了结构化并发编程模型，确保协程在作用域内启动，并在作用域结束时自动取消，避免内存泄漏。简单易用：通过 suspend 关键字和 async、launch 等构建器，协程能够以同步代码的方式编写异步代码，易于理解和维护。 基本用法1.创建协程： // 在 MainScope 上下文中启动协程 val job = GlobalScope.launch(Dispatchers.Main) { // 在后台线程中执行 withContext(Dispatchers.IO) { // 执行耗时任务 } // 返回主线程更新 UI }2.挂起函数： // 定义挂起函数 suspend fun fetchData(): String { delay(1000L) // 模拟网络请求 return "数据" } // 调用挂起函数 GlobalScope.launch { val data = fetchData() println(data) }3.结构化并发： class MyActivity : AppCompatActivity() { private val coroutineScope = CoroutineScope(Dispatchers.Main + Job()) override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // 启动协程 coroutineScope.launch { // 执行任务 } } override fun onDestroy() { super.onDestroy() // 取消协程 coroutineScope.cancel() } } 定时任务示例4.定时任务示例 使用 delay 实现定时任务： fun startRepeatingTask() { coroutineScope.launch { while (isActive) { println("任务执行中...") delay(5000L) // 每5秒执行一次 } } }5.完整实例 class MainActivity : AppCompatActivity() { private val coroutineScope = CoroutineScope(Dispatchers.Main + Job()) override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // 启动定时任务 startRepeatingTask() } private fun startRepeatingTask() { coroutineScope.launch { while (isActive) { // 执行定时任务 println("定时任务执行中...") // 延迟5秒 (5000毫秒) delay(5000L) } } } override fun onDestroy() { super.onDestroy() // 取消协程以避免内存泄漏 coroutineScope.cancel() } } 注意事项 协程取消：确保在适当时机取消协程，以避免内存泄漏，尤其是在 Activity 和 Fragment 中。调度器选择：根据任务类型选择合适的调度器，如 Dispatchers.Main 处理 UI 更新，Dispatchers.IO 处理 I/O 操作。总结 这里我直接给出了一些特定的场景应该使用哪一种定时任务，如果大家的应用场景适合App内部的定时任务，应该优先选择内部的定时任务。 App外的定时任务，都是系统服务的定时任务，不一定保险，毕竟是和厂商（特别是国内的厂商）作对，厂商会想方设法杀死我们的定时任务，毕竟有风险。 关于系统服务的定时任务我感觉自己讲的不是很好，好在给出了一些方案和一些文章，大家如果对一些基础的使用或者底层原理感兴趣，可以自行了解一下。 关于系统服务的周期任务的使用如果有错误，或者版本兼容的问题，又或者有更多或更好的方法，也可以在评论区交流讨论。 |
【本文地址】