基于优先级队列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 :1RunnablePriority: pool-1-thread-2 Priority :12016-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 :5RunnablePriority: pool-1-thread-1 Priority :5RunnablePriority: pool-1-thread-1 Priority :5RunnablePriority: pool-1-thread-2 Priority :5RunnablePriority: pool-1-thread-1 Priority :5RunnablePriority: pool-1-thread-2 Priority :1RunnablePriority: pool-1-thread-2 Priority :1RunnablePriority: pool-1-thread-1 Priority :1over

运行过程：

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

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