基于优先级队列java线程池
背景
最近在看同事的消息平台的问题进行优化，其中一点就是推送来的消息没有区分优先级，造成实时性要求高的不能优先满足，被全网下发的普通优先级占用了，造成消息延迟。
对应的改进一点就是采用把现有线程池改为优先级队列。
实现
创建一个RunnablePriority，它实现Runnable接口和参数化为RunnablePriority类的Comparable接口。
package thread;
/**
* 优先级比较
*
*/
public class RunnablePriority implements Runnable, Comparable<RunnablePriority> {
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 : (priority > o.priority ? 1 : 0);
// System.out.println(priority +"::"+ o.priority);
if (this.getPriority() < o.priority) {
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<Runnable>());
//模拟加入消息
for (int i = 0; i < 5; 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 < 5; 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.