一个 Android 任务队列的实现

最近在做Android项目时遇到这样一个问题：客户端向服务器请求数据，而在网络信号太差的情况下，数据迟迟不到，甚至丢失。服务器为了解决这个问题做了频繁的重发，android 客户端就会收到很多不想要的消息；或者因为消息回来太慢，用户已经失去耐心的去做别的操作了，而那个姗姗来迟的消息的到来就会让用户莫名其妙。
      如何有一个类，在向服务器发出请求的时候就向任务队列中添加一条任务，并启动，等待时间到了以后就丢弃这个任务；在等待时间内如果有相应的响应消息返回的时候，则停掉该任务就解决了这一难题了。
      下面是任务类：

 import java.util.TimerTask;

 public class MsgTask extends TimerTask {
     private long deltaTime;  //时间增量，及任务执行等待时间
     private MsgKey msgKey;
     private MsgProcessor msgProcessor = new MsgProcessor();

     public MsgTask(MsgKey msgKey,long deltaTime) {
         super();
         this.msgKey = msgKey;
         this.deltaTime = deltaTime;
     }

     public long getDeltaTime() {
         return deltaTime;
     }

     public void setDeltaTime(long deltaTime) {
         this.deltaTime = deltaTime;
     }

     public MsgKey getMsgKey() {
         return msgKey;
     }

     public void setMsgKey(MsgKey msgKey) {
         this.msgKey = msgKey;
     }

     @Override
     public void run() {//等待时间到了以后，就执行
         int index = msgKey.getIndex();
         msgProcessor.dealOverTimeMsg(index);
         MsgManager.removeMsgTask(msgKey);
         this.cancel();
     }
 }

为了方便对任务队列的管理，可以写一个任务管理类：

 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Timer;

 import android.util.Log;

 public class MsgManager {
     private static Timer timer = new Timer();
     private static Map<MsgKey, MsgTask> msgTasks = Collections.synchronizedMap(new HashMap<MsgKey, MsgTask>());

     public static void putMsgTask(MsgKey msgKey,MsgTask msgTask) {
         synchronized (msgTasks) {
             msgTasks.put(msgKey, msgTask);
         }
     }

     public static void startMsgTask(MsgKey msgKey,MsgTask msgTask) {
         putMsgTask(msgKey, msgTask);
         timer.schedule(msgTask, msgTask.getDeltaTime());
         Log.d("zyr",""+msgKey.getIndex());
     }

     public static MsgTask removeMsgTask(MsgKey msgKey) {
         MsgTask msgTask = null;
         synchronized (msgTasks) {
             msgTask = msgTasks.remove(msgKey);
         }
         return msgTask;
     }

     public static boolean stopMsgTask(MsgKey msgKey) {
         MsgTask msgTask = removeMsgTask(msgKey);
         if (msgTask != null){
             msgTask.cancel();
             return true;
         }
         return false;
     }
 }

任务需要一个标志，才能方便启动和结束，下面的MsgKey就是用来标记任务的实体类：

 public class MsgKey {
     private int index;

     public int getIndex() {
         return index;
     }

     public void setIndex(int index) {
         this.index = index;
     }

     @Override
     public boolean equals(Object obj) {
         if (obj instanceof MsgKey) {
             MsgKey msgKey = (MsgKey) obj;
             return this.index == msgKey.getIndex();
         } else {
             return false;
         }
     }

     @Override
     public int hashCode() {
         return String.valueOf(this.index).hashCode();
     }
 }

当然，如果等待超时，一定要有相应的处理的：

 public class MsgProcessor {

     /**
      * 处理超时的消息
      * @param index
      */
     public void dealOverTimeMsg(int index){
         switch (index) {
         case 0:
              loginOverTimeHandler();
              break;

         default:
              break;
         }
     }

     private void loginOverTimeHandler(){
         //这里写处理方法
     }
 }

值得注意的是：如果需要把任务添加到任务队列后并立即执行，则用startMsgTask方法，结束这个任务时要用stopMsgTask方法，如果没有这个任务 stopMsgTask返回false；如果需要把任务添加到任务队列但不确定什么时候执行，则用putMsgTask方法，结束这个任务时就用removeMsgTask方法就可以了，如果没有这个任务removeMsgTask返回null。