相信大家做程序遇到比较多的就是队列，排队问题。对于app上这种问题比较多，比如排队下载，排队发送，并发排队网络请求等等。

要如何自己做好一个这样的功能呢。

下面我给大家将一下我对这一块的理解。

首先在android上，用java编写的程序，需要了解一下队列Queue数据结构(如果有特别的兴趣的可以百度一下，资料很多，我就不粘贴了)。

这次我们主要用的是PriortyBlockingQueue,大家可以理解成一个有优先级排序的阻塞队列排队，注意是可以阻塞的。

具体的PriortyBlockingQueue内部实现是堆，有兴趣的也可以去详细查一下资料。

多的就不说了，很多资料大家都能找到，下面直接看实现代码。

TaskManager.class

public classTaskManager {

privatePriorityBlockingQueue mQueue;

privateTaskDispatcher[] mTaskDispatchers;

private volatile staticTaskManager ourInstance;

private final static intMAX_POOL_SIZE = 3;

privateAtomicInteger mSequenceGenerator = newAtomicInteger();

privateTaskManager() { mTaskDispatchers=newTaskDispatchers[MAX_POOL_SIZE];

startTask();

}

public staticTaskManagergetInstance() { if(ourInstance == null) {

synchronized(TaskManager.class) {

if(ourInstance == null) {

ourInstance = newTaskManager();

}

}

}

returnourInstance;

}

public voidstop() {

if(mTaskDispatchers!=null) {

intlen = mTaskDispatchers.length;

TaskDispatcher dispatcher;

for(inti = 0; i < len; i++) {

dispatcher = mTaskDispatchers[i];

if(dispatcher != null) {

dispatcher.quit();

}

}

}

}

public voidstartTask() {

stop();

for(inti = 0; i < mTaskDispatchers.length; i++) {

TaskDispatcher dispatcher = newTaskDispatcher(mQueue); mTaskDispatchers[i] = dispatcher;

dispatcher.start();

}

}

public voidcancelAll() {

stop();

mQueue.clear();

}

public voidcancelTask(Task task) {

if(task != null) {

task.cancel();

}

}

public voidaddTask(Task task) {

task.setSequence(getSequenceNumber());

mQueue.add(downloadTask);

}

}

首先是任务管理，整个类里面其实代码很简单有几个东西组成：

一个是线程个数的数组TaskDispatchers用来分发和执行Task使用。

MAX_POOL_SIZE 是线程池最大个数这里默认是3个。

AtomicInteger这里只是一个integer的原子操作，大家可以理解就是i++,不过他是线程安全的。

TaskDispatcher.class

public classTaskDispatcher extendsThread {

private volatile booleanmQuit = false;

privateBlockingQueue mQueue;

publicTaskDispatcher(BlockingQueue mQueue) {

this.mQueue = mQueue;

}

public voidquit() {

mQuit = true;

interrupt();

}

@Override

public voidrun() {

android.os.Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

Task task;

while(true) {

try{

task = mQueue.take();

if(!task.isRunning()) {

task.run();

}

} catch(InterruptedException e) {

if(mQuit) {

return;

}

continue;

}

}

}

}

分发任务类，其实主要就是用来运行每一个task使用的，本身自己就是一个无限循环的线程，永远在后台运行。这里其实就是要注意的就是停止线程的方法。因为本身的Queue是一个阻塞的，所以只要在外部调用打断会有catch的错误，通过方法来停止一个当前想取消的一个任务，随后需要一个变量来控制一下循环的结束。

Task.class

public abstract classTask implementsRunnable, Comparable {

privateInteger mSequence;

privateString uuid;

public enumPriority {

LOW,

NORMAL,

HIGH,

IMMEDIATE}

public voidTask() {

uuid= UUID.randomUUID().toString();

}

publicPriority getPriority() {

returnPriority.NORMAL;

}

public voidsetSequence(Integer sequence) {

this.mSequence= sequence;

}

@Overridepublic intcompareTo(Task o) {

if(o == null) {

return this.mSequence;

}

if(this.mSequence== null) {

this.mSequence= newInteger(0);

}

if(o.mSequence== null) {

o.mSequence= newInteger(0);

}

Priority left = this.getPriority();

Priority right = o.getPriority();

returnleft == right ?

this.mSequence- o.mSequence: right.ordinal() - left.ordinal();

}

@Overridepublic voidrun() {

}

publicString getUuid() {

returnuuid;

}

public voidsetUuid(String uuid) {

this.uuid= uuid;

}

}

最后一个就是我们的任务了，大家要注意的问题在于Comparable接口,因为刚才说过了，PriorytyBlockingQueue是一个阻塞有优先级的队列，而且在队列里面的类必须实现这个接口，目的是为了让排队在末尾或后面的任务一些需要优先执行的任务可以先执行。

注意：这里没有任务完成回调，需要自己设计，这个在这里就不讲了。

整个队列多线程就搞定了，这个时候如果你想网络请求使用这的话你只需要把自己的网络请求任务类继承Task，实现run方法(这个方法中实现请求的访问和回调)。

最后你只需要在发网络请求的地方调用：如TaskManager.getInstance().addTask(new HttpTask());

就搞定了，整个队列会一直循环执行。

最户提醒一下，在不需要的时候，需要调用一下TaskManager.getInstance().stop();停止所有线程避免造成泄漏。