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相比，这个方法更加考虑系统电量，比如系统在低电量情况下可能不会严格按照设定的间隔时间执行闹钟，因为系统可以调整报警的交付时间，使其同时触发，避免超过必要的唤醒设备。

参数说明

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<Long>() {
                    @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<Long>() {
                    @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<Boolean>() {
                    @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来实现一些后台的操作，使用起来也是很简单。

总结

这里我直接给出了一些特定的场景应该使用哪一种定时任务，如果大家的应用场景适合App内部的定时任务，应该优先选择内部的定时任务。

App外的定时任务，都是系统服务的定时任务，不一定保险，毕竟是和厂商（特别是国内的厂商）作对，厂商会想方设法杀死我们的定时任务，毕竟有风险。

关于系统服务的定时任务我感觉自己讲的不是很好，好在给出了一些方案和一些文章，大家如果对一些基础的使用或者底层原理感兴趣，可以自行了解一下。

关于系统服务的周期任务的使用如果有错误，或者版本兼容的问题，又或者有更多或更好的方法，也可以在评论区交流讨论。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/240565