定时任务组件

项目中总是会因为各种需求添加各种定时任务，所以就打算小结一下Android中如何实现定时任务，下面的解决方案的案例大部分都已在实际项目中实践，特此列出供需要的朋友参考，如果有什么使用不当或者存在什么问题，欢迎留言指出！直接上干货！

解决方案

普通线程sleep的方式实现定时任务

创建一个thread，然后让它在while循环里一直运行着，通过sleep方法来达到定时任务的效果，这是最常见的，可以快速简单地实现。但是这是java中的实现方式，不建议使用

    public class ThreadTask {      public static void main(String[] args) {          final long timeInterval = 1000;          Runnable runnable = new Runnable() {              public void run() {                  while (true) {                      System.out.PRintln("execute task");                      try {                          Thread.sleep(timeInterval);                      } catch (InterruptedException e) {                          e.printStackTrace();                      }                  }              }          };          Thread thread = new Thread(runnable);          thread.start();      }  } 
Timer实现定时任务
和普通线程+sleep（long）+Handler的方式比，优势在于
可以控制TimerTask的启动和取消第一次执行任务时可以指定delay的时间。
在实现时，Timer类调度任务，TimerTask则是通过在run()方法里实现具体任务（然后通过Handler与线程协同工作，接收线程的消息来更新主UI线程的内容）。
Timer实例可以调度多任务，它是线程安全的。当Timer的构造器被调用时，它创建了一个线程，这个线程可以用来调度任务。
   /**    * start Timer    */    protected synchronized void startPlayerTimer() {        stopPlayerTimer();        if (playTimer == null) {            playTimer = new PlayerTimer();            Timer m_musictask = new Timer();            m_musictask.schedule(playTimer, 5000, 5000);        }    }    /**     * stop Timer     */    protected synchronized void stopPlayerTimer() {        try {            if (playTimer != null) {                playTimer.cancel();                playTimer = null;            }        } catch (Exception e) {            e.printStackTrace();        }    }    public class PlayerTimer extends TimerTask {        public PlayerTimer() {        }        public void run() {            //execute task        }    }
然而Timer是存在一些缺陷的
Timer在执行定时任务时只会创建一个线程，所以如果存在多个任务，且任务时间过长，超过了两个任务的间隔时间，会发生一些缺陷如果Timer调度的某个TimerTask抛出异常，Timer会停止所有任务的运行Timer执行周期任务时依赖系统时间,修改系统时间容易导致任务被挂起（如果当前时间小于执行时间）
注意：
Android中的Timer和java中的Timer还是有区别的，但是大体调用方式差不多Android中需要根据页面的生命周期和显隐来控制Timer的启动和取消 java中Timer：  Android中的Timer：  
ScheduledExecutorService实现定时任务
ScheduledExecutorService是从JDK1.5做为并发工具类被引进的，存在于java.util.concurrent，这是最理想的定时任务实现方式。相比于上面两个方法，它有以下好处： 
相比于Timer的单线程，它是通过线程池的方式来执行任务的，所以可以支持多个任务并发执行 ,而且弥补了上面所说的Timer的缺陷可以很灵活的去设定第一次执行任务delay时间 提供了良好的约定，以便设定执行的时间间隔 
简例：
public class ScheduledExecutorServiceTask {      public static void main(String[] args)     {          final TimerTask task = new TimerTask()          {              @Override              public void run()              {                 //execute task              }          };           ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);          pool.scheduleAtFixedRate(task, 0 , 1000, TimeUnit.MILLISECONDS);      }  }
实际案例背景：
应用中多个页面涉及比赛信息展示（包括比赛状态，比赛结果），因此需要实时更新这些数据
思路分析：
多页面多接口刷新 就是每个需要刷新的页面基于自身需求基于特定接口定时刷新每个页面要维护一个定时器，然后基于页面的生命周期和显隐进行定时器的开启和关闭（保证资源合理释放）而且这里的刷新涉及到是刷新局部数据还是整体数据，刷新整体数据效率会比较低，显得非常笨重多页面单接口刷新 接口给出一组需要实时进行刷新的比赛数据信息，客户端基于id进行统一过滤匹配通过单例封装统一定时刷新回调接口（注意内存泄露的问题，页面销毁时关闭ScheduledExecutorService ）需要刷新的item统一调用，入口唯一，方便维护管理，扩展性好局部刷新，效率高
public class PollingStateMachine implements INetCallback {    private static volatile PollingStateMachine instance = null;    private ScheduledExecutorService pool;    public static final int TYPE_MATCH = 1;    private Map matchMap = new HashMap<>();    private List<WeakReference<View>> list = new ArrayList<>();    private Handler handler;    // private constructor suppresses    private PollingStateMachine() {        defineHandler();        pool = Executors.newSingleThreadScheduledExecutor();        pool.scheduleAtFixedRate(new Runnable() {            @Override            public void run() {                doTasks();            }        }, 0, 10, TimeUnit.SECONDS);    }    private void doTasks() {        ThreadPoolUtils.execute(new PollRunnable(this));    }    public static PollingStateMachine getInstance() {        // if already inited, no need to get lock everytime        if (instance == null) {            synchronized (PollingStateMachine.class) {                if (instance == null) {                    instance = new PollingStateMachine();                }            }        }        return instance;    }    public <VIEW extends View> void subscibeMatch(VIEW view, OnViewRefreshStatus onViewRefreshStatus) {        subscibe(TYPE_MATCH,view,onViewRefreshStatus);    }    private <VIEW extends View> void subscibe(int type, VIEW view, OnViewRefreshStatus onViewRefreshStatus) {        view.setTag(onViewRefreshStatus);        if (type == TYPE_MATCH) {            onViewRefreshStatus.update(view, matchMap);        }         for (WeakReference<View> viewSoftReference : list) {            View textView = viewSoftReference.get();            if (textView == view) {                return;            }        }        WeakReference<View> viewSoftReference = new WeakReference<View>(view);        list.add(viewSoftReference);    }    public void updateView(final int type) {        Iterator<WeakReference<View>> iterator = list.iterator();        while (iterator.hasNext()) {            WeakReference<View> next = iterator.next();            final View view = next.get();            if (view == null) {                iterator.remove();                continue;            }            Object tag = view.getTag();            if (tag == null || !(tag instanceof OnViewRefreshStatus)) {                continue;            }            final OnViewRefreshStatus onViewRefreshStatus = (OnViewRefreshStatus) tag;            handler.post(new Runnable() {                @Override                public void run() {                    if (type == TYPE_MATCH) {                        onViewRefreshStatus.update(view, matchMap);                    }                 }            });        }    }    public void clear() {        pool.shutdown();        instance = null;    }    private Handler defineHandler() {        if (handler == null && Looper.myLooper() == Looper.getMainLooper()) {            handler = new Handler();        }        return handler;    }    @Override    public void onNetCallback(int type, Map msg) {        if (type == TYPE_MATCH) {            matchMap=msg;        }         updateView(type);    }}
需要刷新的item调用
PollingStateMachine.getInstance().subscibeMatch(tvScore, new OnViewRefreshStatus<ScoreItem, TextView>(matchViewItem.getMatchID()) {            @Override            public void OnViewRefreshStatus(TextView view, ScoreItem scoreItem) {                //刷新处理                }        });
网络数据回调接口
public interface INetCallback {    void onNetCallback(int type,Map msg);}
刷新回调接口：
public abstract class OnViewRefreshStatus<VALUE, VIEW extends View> {    private static final String TAG = OnViewRefreshStatus.class.getSimpleName();    private long key;    public OnViewRefreshStatus(long key) {        this.key = key;    }    public long getKey() {        return key;    }    public void update(final VIEW view, Map<Long, VALUE> map) {        final VALUE value = map.get(key);        if (value == null) {            return;        }        OnViewRefreshStatus(view, value);    }    public abstract void OnViewRefreshStatus(VIEW view, VALUE value);}
Handler实现定时任务
通过Handler延迟发送消息的形式实现定时任务。
这里通过一个定时发送socket心跳包的案例来介绍如何通过Handler完成定时任务
案例背景
由于移动设备的网络的复杂性，经常会出现网络断开，如果没有心跳包的检测， 客户端只会在需要发送数据的时候才知道自己已经断线，会延误，甚至丢失服务器发送过来的数据。 所以需要提供心跳检测
下面的代码只是用来说明大体实现流程
WebSocket初始化成功后，就准备发送心跳包每隔30s发送一次心跳创建的时候初始化Handler，销毁的时候移除Handler消息队列
private static final long HEART_BEAT_RATE = 30 * 1000;//目前心跳检测频率为30sprivate Handler mHandler;private Runnable heartBeatRunnable = new Runnable() {        @Override        public void run() {            // excute task            mHandler.postDelayed(this, HEART_BEAT_RATE);        }    };public void onCreate() {     //初始化Handler    }//初始化成功后，就准备发送心跳包public void onConnected() {        mHandler.removeCallbacks(heartBeatRunnable);        mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);    }public void onDestroy() {        mHandler.removeCallbacks(heartBeatRunnable)    }
注意：这里开启的runnable会在这个handler所依附线程中运行，如果handler是在UI线程中创建的，那么postDelayed的runnable自然也依附在主线程中。
AlarmManager实现精确定时操作
我们使用Timer或者handler的时候会发现，delay时间并没有那么准。如果我们需要一个严格准时的定时操作，那么就要用到AlarmManager，AlarmManager对象配合Intent使用，可以定时的开启一个Activity,发送一个BroadCast,或者开启一个Service.
案例背景
在比赛开始前半个小时本地定时推送关注比赛的提醒信息
AndroidManifest.xml中声明一个全局广播接收器
  <receiver            android:name=".receiver.AlarmReceiver"            android:exported="false">            <intent-filter>                <action android:name="${applicationId}.BROADCAST_ALARM" />            </intent-filter>        </receiver>
接收到action为IntentConst.Action.matchRemind的广播就展示比赛 提醒的Notification
public class AlarmReceiver extends BroadcastReceiver {    private static final String TAG = "AlarmReceiver";    @Override    public void onReceive(Context context, Intent intent) {        if (intent == null) {            return;        }        String action = intent.getAction();        if (TextUtils.equals(action, IntentConst.Action.matchRemind)) {            //通知比赛开始            long matchID = intent.getLongExtra(Net.Param.ID, 0);            showNotificationRemindMe(context, matchID);        }    }}
AlarmUtil提供设定闹铃和取消闹铃的两个方法
public class AlarmUtil {    private static final String TAG = "AlarmUtil";    public static void controlAlarm(Context context, long startTime,long matchId, Intent nextIntent) {        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);        PendingIntent pendingIntent = PendingIntent.getBroadcast(context, (int) matchId, nextIntent,                PendingIntent.FLAG_ONE_SHOT);        alarmManager.set(AlarmManager.RTC_WAKEUP, startTime, pendingIntent);    }    public static void cancelAlarm(Context context, String action,long matchId) {        Intent intent = new Intent(action);        PendingIntent sender = PendingIntent.getBroadcast(                context, (int) matchId, intent, 0);        // And cancel the alarm.        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);        alarmManager.cancel(sender);    }}
关注比赛的时候，会设置intent的action为IntentConst.Action.matchRemind，会根据比赛的开始时间提前半小时设定闹铃时间，取消关注比赛同时取消闹铃
   if (isSetAlarm) {            long start_tm = matchInfo.getStart_tm();            long warmTime = start_tm - 30 * 60;            Intent intent = new Intent(IntentConst.Action.matchRemind);            intent.putExtra(Net.Param.ID, matchInfo.getId());            AlarmUtil.controlAlarm(context, warmTime * 1000,matchInfo.getId(), intent);            Gson gson = new Gson();            String json = gson.toJson(matchInfo);            SportDao.getInstance(context).insertMatchFollow(eventID, matchInfo.getId(), json, matchInfo.getType());        } else {            AlarmUtil.cancelAlarm(context, IntentConst.Action.matchRemind,matchInfo.getId());            SportDao.getInstance(context).deleteMatchFollowByID(matchInfo.getId());        }
Android Priority Job Queue是一款专门为Android平台编写，实现了Job Queue的后台任务队列类库，能够轻松的在后台执行定时任务，提高用户体验和应用的稳定性。Github托管地址：https://github.com/idaretobe/android-priority-jobqueue
https://github.com/idaretobe/android-job
http://www.opensymphony.com/quartz/