Android中具有优先级队列的服务

我想实现一个（）来处理基于简单数字优先级的意图。服务应首先处理优先级较高的意图，而不是优先级较低的意图

---

安卓系统上已经有这样的东西了吗？如果没有，有关于如何实现它的指针吗？

没有。不过，

IntentService

没有太多内容。制作一个

PriorityIntentService

由

PriorityBlockingQueue

支持，而不是一个

处理程序

+

活套

，应该不会太长。

基于Commonware的答案和Android的

IntentService

首次尝试实现具有优先级的意图服务。将进行广泛测试并进行相应编辑

public abstract class PriorityIntentService extends Service {

    private final class QueueItem implements Comparable<QueueItem> {
        Intent intent;
        int priority;
        int startId;

        @Override
        public int compareTo(QueueItem another) {
            if (this.priority < another.priority) {
                return -1;
            } else if (this.priority > another.priority) {
                return 1;
            } else {
                return (this.startId < another.startId) ? -1 : 1;
            }
        }
    }
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            try {
                final QueueItem item = mQueue.take();
                onHandleIntent(item.intent);
                if (mQueue.isEmpty()) {
                    PriorityIntentService.this.stopSelf();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static final String EXTRA_PRIORITY = "priority";
    private String mName;
    private PriorityBlockingQueue<QueueItem> mQueue;
    private boolean mRedelivery;
    private volatile ServiceHandler mServiceHandler;
    private volatile Looper mServiceLooper;

    public PriorityIntentService(String name) {
        super();
        mName = name;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("PriorityIntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
        mQueue = new PriorityBlockingQueue<QueueItem>();
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

    protected abstract void onHandleIntent(Intent intent);

    @Override
    public void onStart(Intent intent, int startId) {
        final QueueItem item = new QueueItem();
        item.intent = intent;
        item.startId = startId;
        final int priority = intent.getIntExtra(EXTRA_PRIORITY, 0);
        item.priority = priority;
        mQueue.add(item);
        mServiceHandler.sendEmptyMessage(0);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }
}

公共抽象类PriorityIntentService扩展服务{
私有最终类QueueItem实现了可比较的{
意图；
int优先级；
int startId；
@凌驾
public int compareTo（队列项目另一个）{
if（this.priorityother.priority）{
返回1；
}否则{
返回（this.startId<另一个.startId）？-1:1；
}
}
}
私有最终类ServiceHandler扩展处理程序{
公共服务处理程序（活套-活套）{
超级（活套）；
}
@凌驾
公共无效handleMessage（消息消息消息）{
试一试{
final QueueItem=mQueue.take（）；
onHandleIntent（项目意图）；
if（mQueue.isEmpty（））{
PriorityIntentService.this.stopSelf（）；
}
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
公共静态最终字符串EXTRA_PRIORITY=“PRIORITY”；
私有字符串mName；
私有优先级阻塞队列MQUE；
私有布尔mRedelivery；
私有易失性ServiceHandler mServiceHandler；
私有易失性Looper-mServiceLooper；
public PriorityIntentService（字符串名称）{
超级（）；
mName=名称；
}
@凌驾
公共IBinder onBind（意向）{
返回null；
}
@凌驾
public void onCreate（）{
super.onCreate（）；
HandlerThread线程=新的HandlerThread（“PriorityIntentService[“+mName+”]”）；
thread.start（）；
mServiceLooper=thread.getLooper（）；
MSServiceHandler=新的ServiceHandler（MSServiceLooper）；
mQueue=new PriorityBlockingQueue（）；
}
@凌驾
公共空间{
mServiceLooper.quit（）；
}
受保护的抽象内容无效（意图）；
@凌驾
公共无效启动（Intent Intent，int startId）{
final QueueItem=new QueueItem（）；
item.intent=意图；
item.startId=startId；
final int priority=intent.getIntExtra（额外优先级，0）；
item.priority=优先级；
mQueue.add（项目）；
mServiceHandler.sendEmptyMessage（0）；
}
@凌驾
公共int onStartCommand（Intent Intent、int标志、int startId）{
onStart（意向，startId）；
返回MRE交付？开始重新交付意图：开始不粘；
}
public void setIntentRedelivery（已启用布尔值）{
mRedelivery=已启用；
}
}

谢谢您的Commonware。你介意添加一点伪代码来为我指明正确的方向吗？我想PriorityBlockingQueue应该存储意图，比较器应该区分不同的优先级。但是，不确定如何对相同优先级的意图进行排序。@hgpc：如果您没有任何其他条件，请比较哈希代码或其他内容。@commonware意图是否有某种时间戳？@hgpc：我不知道。不过，你可以多加一个。我想这就是你的优先权所在。@commonware是的。以防有什么东西可以重复使用。