后台执行的定时任务

在后台实现定时任务，我们可以用Alarm机制，开启服务来实现。

首先来介绍一下Alarm机制，它主要是借助了AlarmManager类来实现的。这个类和NotificationManager有点类似，都是通过调用Context的getSystemService()方法来获取实例的，只是这里需要传入的参数是Contex_ALARM_SERVICE。

因此，获取一个AlarmManager的实例就可以写成：

  AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);

接下来，调用AlarmManager的set()方法就可以设置一个定时任务了，比如说想要设定一个任务在10秒以后执行，就可以写成:

long triggerAtTime=SystemClock.elapsedRealTime()+10*1000;

manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pendingIntent);

set()方法中需要传入的三个参数稍微有点复杂

第一个参数是一个整型参数，用于指定AlarmManager 的工作类型，有四种值可选，分别是

ELAPSED_REALTIME、ELAPSED_REALTIME_WAKEUP、 RTC和 RTC_WAKEUP。

其中 ELAPSED_REALTIME 表示让定时任务的触发时间从系统开 机开始算起，但不会唤醒 CPU。

ELAPSED_REALTIME_WAKEUP同样表示让定时任务的触 发时间从系统开机开始算起，但会唤醒 CPU。

RTC表示让定时任务的触发时间从 1970年 1 月 1日 0点开始算起，但不会唤醒 CPU。

RTC_WAKEUP同样表示让定时任务的触发时间从 1970年 1月 1日 0点开始算起，但会唤醒 CPU。

使用 SystemClock.elapsedRealtime()方法可 以获取到系统开机至今所经历时间的毫秒数，使用

System.currentTimeMillis()方法可以获取 到 1970年 1月 1日 0点至今所经历时间的毫秒数。

第二个参数，就是定时任务触发的时间，以毫秒为单位。

如果第一个参数使用的是ELAPSED_REALTIME或ELAPSED_REALTIME_WAKEUP， 则这里传入开机至今的时间再加上延迟执行的时间。

如果第一个参数使用的是 RTC 或 RTC_WAKEUP，则这里传入 1970年 1月 1日 0点至今的时间再加上延迟执行的时间。

第三个参数是一个pendingIntent，对于它你应该已经不会陌生了吧。这里我们一般会调

getBroadcast()方法来获取一个能够执行广播的 PendingIntent。这样当定时任务被触发的时 候，广播接收

器的 onReceive()方法就可以得到执行。

首先，我们来创建一个长时间运行的服务，创建一个ServiceBestPractice项目，然后新增一个LongRunningService类，代码如下：

public class LongRunningService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
//                Toast.makeText(getApplication(), "定时任务开始", Toast.LENGTH_SHORT).show();
                Log.d("LongRunningService", "executed at " + new Date());
            }
        }).start();
        AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
        int anHour = 60 * 1000;//这是一分钟的毫秒数
        long triggerAtTime = SystemClock.elapsedRealtime() + anHour;
        Intent i = new Intent(this, AlarmReceiver.class);
        PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);
        manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
        return super.onStartCommand(intent, flags, startId);
    }
}

我们在onStartCommand()方法里开启了一个子线程，然后在子线程里就可以执行具体的逻辑操作了。

创建线程之后的代码就是我们刚刚讲解的 Alarm 机制的用法了，先是获取到了 AlarmManager的实例，然

后定义任务的触发时间为一小时后，再使用 PendingIntent指定处 理定时任务的广播接收器为

AlarmReceiver，最后调用 set()方法完成设定。 显然，AlarmReceiver目前还不存在呢，所以下一步就是要

新建一个 AlarmReceiver类， 并让它继承自 BroadcastReceiver，代码如下所示：

public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Intent i = new Intent(context, LongRunningService.class);
        context.startService(i);
    }
}

onReceive()方法里的代码非常简单，就是构建出了一个 Intent 对象，然后去启动 LongRunningService这个服务。

那么这里为什么要这样写呢？其实在不知不觉中，这就已经 将一个长期在后台定时运行的服务完成了。因为

一旦启动 LongRunningService，就会在 onStartCommand()方法里设定一个定时任务，这样一小时后

AlarmReceiver的 onReceive()方 法就将得到执行，然后我们在这里再次启动 LongRunningService，这样

就形成了一个永久的 循环，保证 LongRunningService可以每隔一小时就会启动一次，一个长期在后台定时

运行的 服务自然也就完成了。 接下来的任务也很明确了，就是我们需要在打开程序的时候启动一次

LongRunningService， 之后 LongRunningService就可以一直运行了。

修改 MainActivity中的代码，如下所示：

public class AlarmActivity extends BaseActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Intent intent = new Intent(this, LongRunningService.class);
        startService(intent);
    }
}

最后别忘了，我们所用到的服务和广播接收器都要在 AndroidManifest.xml中注册才行。