java线程优先级队列等待_基于优先级队列java线程池

背景

最近在看同事的消息平台的问题进行优化，其中一点就是推送来的消息没有区分优先级，造成实时性要求高的不能优先满足，被全网下发的普通优先级占用了，造成消息延迟。

对应的改进一点就是采用把现有线程池改为优先级队列。

实现

创建一个RunnablePriority，它实现Runnable接口和参数化为RunnablePriority类的Comparable接口。

package thread;

/**

* 优先级比较

*

*/

public class RunnablePriority  implements Runnable, Comparable {

private int priority;

public int getPriority() {

return priority;

}

public RunnablePriority(int priority) {

this.priority = priority;

}

@Override

public int compareTo(RunnablePriority o) {

// 复写此方法进行任务执行优先级排序

// return priority  o.priority ? 1 : 0);

// System.out.println(priority +"::"+ o.priority);

if (this.getPriority() 

return 1;

}

if(this.getPriority()>o.priority){

return -1;

}

return 0;

}

@Override

public void run() {

System.out.printf("RunnablePriority: %s Priority :%d\n",Thread.currentThread().getName(),priority);

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

// 执行任务代码..

}

}这个类实现声明在Comparable接口中的compareTo()方法。它接收一个RunnablePriority对象作为参数，比较这两个对象(当前对象和参数对象)的优先级。让优先级高的任务先于优先级低的任务执行。

其中run方法用来处理业务。

测试主类如下：

package thread;

import java.text.SimpleDateFormat;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.PriorityBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

* 线程池队列插队Demo，自定义线程池然后使用PriorityBlockingQueue类实现，

*

*/

public class ThreadExecutor {

public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss::SSS");

// public ExecutorService singleThreadExecutor =

// Executors.newSingleThreadExecutor();

static int count =0;

public static void main(String[] args) {

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 1, TimeUnit.MILLISECONDS, new PriorityBlockingQueue());

//模拟加入消息

for (int i = 0; i 

System.out.println(ThreadExecutor.sdf.format(System.currentTimeMillis()) + "加入消息～～～加入队列第" + (++count) + "条消息！");

executor.execute(new RunnablePriority(1));

}

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

//模拟插入消息

for (int i = 0; i 

System.out.println(ThreadExecutor.sdf.format(System.currentTimeMillis()) + "插入消息～～～～插入队列第" + (++count) + "条消息！");

executor.execute(new RunnablePriority(5));

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

e.printStackTrace();

}

//结束

executor.shutdown();

try {

executor.awaitTermination(1, TimeUnit.DAYS);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("over");

}

}

这个类创建一个ThreadPoolExecutor对象，名为executor。使用参数化为Runnable接口的PriorityBlockingQueue作为执行者用来存储待处理任务的队列。

然后分别模拟插入不同优先级任务，最后结束。

运行结果如下：

2016-04-26 13:58:55::447加入消息～～～加入队列第1条消息！

2016-04-26 13:58:55::449加入消息～～～加入队列第2条消息！

2016-04-26 13:58:55::449加入消息～～～加入队列第3条消息！

2016-04-26 13:58:55::449加入消息～～～加入队列第4条消息！

2016-04-26 13:58:55::449加入消息～～～加入队列第5条消息！

RunnablePriority: pool-1-thread-1 Priority :1

RunnablePriority: pool-1-thread-2 Priority :1

2016-04-26 13:58:55::549插入消息～～～～插入队列第6条消息！

2016-04-26 13:58:55::549插入消息～～～～插入队列第7条消息！

2016-04-26 13:58:55::549插入消息～～～～插入队列第8条消息！

2016-04-26 13:58:55::549插入消息～～～～插入队列第9条消息！

2016-04-26 13:58:55::549插入消息～～～～插入队列第10条消息！

RunnablePriority: pool-1-thread-2 Priority :5

RunnablePriority: pool-1-thread-1 Priority :5

RunnablePriority: pool-1-thread-1 Priority :5

RunnablePriority: pool-1-thread-2 Priority :5

RunnablePriority: pool-1-thread-1 Priority :5

RunnablePriority: pool-1-thread-2 Priority :1

RunnablePriority: pool-1-thread-2 Priority :1

RunnablePriority: pool-1-thread-1 Priority :1

over

运行过程：

我们将执行者转换成一个基于优先级的(执行者)。你只要传入一个参数化为Runnable接口的PriorityBlockingQueue对象作为参数。但是，使用执行者时，你应该知道存储在优先级列队中的所有对象必须实现Comparable接口。

我们已经实现了RunnablePriority类，它实现了Runnable接口和Comparable接口，它被存储在优先级队列中。这个类有一个Priority属性，用来存储任务的优先级。如果一个任务的这个属性有更高的值，它将被更早的执行。compareTo()方法决定任务在优先级列队中的顺序。在Main类，你提交10个不同优先级的任务给执行者。你提交给执行者的第一个任务将第一个被执行。由于执行者闲置的，正在等待任务被执行，当第一个任务到达执行者时，执行者立即执行它们。你已经创建有2个执行线程的执行者，所以，前两个任务将第一个被执行。然后，剩下的任务将按它们的优先级来执行。就是有限执行5，再执行剩下的1.