基于优先级队列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.