Java 中队列和优先队列的使用

     

队列的使用（点击打开链接）

今天跟大家来看看如何在项目中使用队列。首先我们要知道使用队列的目的是什么？一般情况下，如果是一些及时消息的处理，并且处理时间很短的情况下是不需要使用队列的，直接阻塞式的方法调用就可以了。但是，如果在消息处理的时候特别费时间，这个时候如果有新的消息来了，就只能处于阻塞状态，造成用户等待。这个时候在项目中引入队列是十分有必要的。当我们接受到消息后，先把消息放到队列中，然后再用新的线程进行处理，这个时候就不会有消息的阻塞了。下面就跟大家介绍两种队列的使用，一种是基于内存的，一种是基于数据库的。

     首先，我们来看看基于内存的队列。在Java的并发包中已经提供了BlockingQueue的实现，比较常用的有ArrayBlockingQueue和LinkedBlockingQueue，前者是以数组的形式存储，后者是以Node节点的链表形式存储。至于数组和链表的区别这里就不多说了。

BlockingQueue 队列常用的操作方法:

      1.往队列中添加元素: add(), put(), offer()

      2.从队列中取出或者删除元素: remove() element()  peek()   poll()  take()

每个方法的说明如下：

      offer()方法往队列添加元素如果队列已满直接返回false,队列未满则直接插入并返回true;

      add()方法是对offer()方法的简单封装.如果队列已满,抛出异常new IllegalStateException("Queue full");

       put()方法往队列里插入元素,如果队列已经满,则会一直等待直到队列为空插入新元素,或者线程被中断抛出异常.

       remove()方法直接删除队头的元素:

       peek()方法直接取出队头的元素,并不删除.

       element()方法对peek方法进行简单封装,如果队头元素存在则取出并不删除,如果不存在抛出异常NoSuchElementException()

       poll()方法取出并删除队头的元素,当队列为空,返回null;

       take()方法取出并删除队头的元素,当队列为空,则会一直等待直到队列有新元素可以取出,或者线程被中断抛出异常

offer()方法一般跟poll()方法相对应, put()方法一般跟take()方法相对应.日常开发过程中offer()与poll()方法用的相对比较频繁.

下面用一个例子来看看是怎么使用的。

[java]  view plain  copy

1. import java.util.concurrent.BlockingQueue;  
2. import java.util.concurrent.Executors;  
3. import java.util.concurrent.LinkedBlockingQueue;  
4. import java.util.concurrent.ScheduledExecutorService;  
5. import java.util.concurrent.TimeUnit;  
6.   
7. public class UserTask {  
8.     //队列大小  
9.     private final int QUEUE_LENGTH = 10000*10;  
10.     //基于内存的阻塞队列  
11.     private BlockingQueue<String> queue = new LinkedBlockingQueue<String>(QUEUE_LENGTH);  
12.     //创建计划任务执行器  
13.     private ScheduledExecutorService es = Executors.newScheduledThreadPool(1);  
14.   
15.     /** 
16.      * 构造函数，执行execute方法 
17.      */  
18.     public UserTask() {  
19.         execute();  
20.     }  
21.       
22.     /** 
23.      * 添加信息至队列中 
24.      * @param content 
25.      */  
26.     public void addQueue(String content) {  
27.         queue.add(content);  
28.     }  
29.       
30.     /** 
31.      * 初始化执行 
32.      */  
33.     public void execute() {  
34.         //每一分钟执行一次  
35.         es.scheduleWithFixedDelay(new Runnable(){  
36.             public void run() {  
37.                 try {  
38.                     String content = queue.take();  
39.                     //处理队列中的信息。。。。。  
40.                     System.out.println(content);  
41.                 } catch (InterruptedException e) {  
42.                     e.printStackTrace();  
43.                 }  
44.             }  
45.               
46.         }, 0, 1, TimeUnit.MINUTES);  
47.     }  
48. }  

 
        以上呢，就是基于内存的队列的介绍，基于内存的队列，队列的大小依赖于JVM内存的大小，一般如果是内存占用不大且处理相对较为及时的都可以采用此种方法。如果你在队列处理的时候需要有失败重试机制，那么用此种队列就不是特别合适了。下面就说说基于数据库的队列。

       基于数据库的队列，很好理解，就是接收到消息之后，把消息存入数据库中，设置消费时间、重试次数等，再用新的线程从数据库中读取信息，进行处理。首先来看看数据库的设计。

字段	类型	说明
queue_id	bigint	队列ID，唯一标识
create_time	bigint	创建时间
type	int	业务类型
status	int	处理状态位 : 1:有效可处理（active） 3：临时被占用 （locked） 5：处理完毕 标记删除（deleted）
consume_status	int	消费状态：1:未消费  2:消费成功 3：消费失败，等待下次消费 4：作废
update_time	bigint	更新时间
locker	varchar	占用标签
last_consume_time	bigint	最后一次消费时间
next_consume_time	bigint	可消费开始时间
consume_count	int	消费次数
json_data	text	数据信息 json格式

代码示例如下：

[java]  view plain  copy

1. /** 
2.      * 批量获取 可以消费的消息 
3.      * 先使用一个时间戳将被消费的消息锁定，然后再使用这个时间戳去查询锁定的数据。 
4.      * @param count 
5.      * @return 
6.      */  
7.     public List<Queue> findActiveQueueNew(int count) {  
8.         //先去更新数据  
9.         String locker = String.valueOf(System.currentTimeMillis())+random.nextInt(10000);  
10.         int lockCount = 0;  
11.         try {  
12.                         //将status为1的更新为3，设置locker，先锁定消息  
13.             lockCount = queueDAO.updateActiveQueue(PayConstants.QUEUE_STATUS_LOCKED,  
14.                     PayConstants.QUEUE_STATUS_ACTIVE, count, locker);  
15.         } catch (Exception e) {  
16.             logger.error(  
17.                     "QueueDomainRepository.findActiveQueueNew error occured!"  
18.                             + e.getMessage(), e);  
19.             throw new TuanRuntimeException(  
20.                     PayConstants.SERVICE_DATABASE_FALIURE,  
21.                     "QueueDomainRepository.findActiveQueue error occured!", e);  
22.         }  
23.           
24.         //如果锁定的数量为0，则无需再去查询  
25.         if(lockCount == 0){  
26.             return null;  
27.         }  
28.                   
29.         //休息一会在再询，防止数据已经被更改  
30.         try {  
31.             Thread.sleep(1);  
32.         } catch (Exception e) {  
33.             logger.error("QueueDomainRepository.findActiveQueue error sleep occured!"  
34.                     + e.getMessage(), e);  
35.         }  
36.         List<Queue> activeList = null;  
37.         try {  
38.             activeList = queueDAO.getByLocker(locker);  
39.         } catch (Exception e) {  
40.             logger.error("QueueDomainRepository.findActiveQueue error occured!"  
41.                     + e.getMessage(), e);  
42.             throw new TuanRuntimeException(  
43.                     PayConstants.SERVICE_DATABASE_FALIURE,  
44.                     "QueueDomainRepository.findActiveQueue error occured!",e);  
45.         }  
46.         return activeList;  
47.     }  

获取到消息之后，还需要再判断消息是否合法，如是否达到最大消费次数，消息是否已被成功消费，等，判断代码如下：

[java]  view plain  copy

1. /** 
2.      * 验证队列modle 的合法性 
3.      *  
4.      * @param model 
5.      * @return boolean true，消息还可以消费。false,消息不允许消费。 
6.      */  
7.     public boolean validateQueue(final QueueModel model){  
8.         int consumeCount = model.getConsumeCount();  
9.         if (consumeCount >= PayConstants.QUEUE_MAX_CONSUME_COUNT) {  
10.             //消费次数超过了最大次数  
11.             return false;  
12.         }  
13.         int consumeStatus = model.getConsumeStatus();  
14.         if(consumeStatus == PayConstants.QUEUE_STATUS_CONSUMER_SUCCESS){  
15.             //消息已经被成功消费  
16.             return false;  
17.         }  
18.         QueueStatusEnum queueStatusEnum  = model.getQueueStatusEnum();  
19.         if(queueStatusEnum == null || queueStatusEnum != QueueStatusEnum.LOCKED){  
20.             //消息状态不正确  
21.             return false;  
22.         }  
23.         String jsonData = model.getJsonData();  
24.         if(StringUtils.isEmpty(jsonData)){  
25.             //消息体为空  
26.             return false;  
27.         }  
28.         return true;  
29.     }  

消息处理完毕之后，根据消费结果修改数据库中的状态。

[java]  view plain  copy

1. public void consume(boolean isDelete, Long consumeMinTime,  
2.             String tradeNo,int consumeCount) {  
3.         QueueDO queueDO  = new QueueDO();  
4.         if (!isDelete) {  
5.             //已经到了做大消费次数，消息作废 不再处理  
6.             if (consumeCount >= PayConstants.QUEUE_MAX_CONSUME_COUNT) {  
7.                 //达到最大消费次数的也设置为消费成功  
8.                                 queueDO.setConsumeStatus(PayConstants.QUEUE_STATUS_CONSUMER_SUCCESS);  
9.                 queueDO.setStatus(PayConstants.QUEUE_STATUS_CANCEL);  
10.             } else {  
11.                 queueDO.setConsumeStatus(PayConstants.QUEUE_STATUS_CONSUMER_FAILED);      
12.                 //设置为可用状态等待下次继续发送  
13.                 queueDO.setStatus(PayConstants.QUEUE_STATUS_ACTIVE);  
14.             }  
15.         } else {  
16.             //第三方消费成功  
17.             queueDO.setConsumeStatus(PayConstants.QUEUE_STATUS_CONSUMER_SUCCESS);  
18.             queueDO.setStatus(PayConstants.QUEUE_STATUS_DELETED);  
19.         }  
20.         queueDO.setNextConsumeTime(consumeMinTime == null ? QueueRuleUtil  
21.                 .getNextConsumeTime(consumeCount) : consumeMinTime);  
22.         if (StringUtils.isNotBlank(tradeNo)) {  
23.             queueDO.setTradeNo(tradeNo);  
24.         }  
25.         long now = System.currentTimeMillis();  
26.         queueDO.setUpdateTime(now);  
27.         queueDO.setLastConsumeTime(now);  
28.         queueDO.setConsumeCount(consumeCount);  
29.         queueDO.setQueueID(id);  
30.         setQueueDOUpdate(queueDO);  
31.     }  

下次消费时间的计算如下：根据消费次数计算，每次消费存在递增的时间间隔。

[java]  view plain  copy

1. /** 
2.  * 队列消费 开始时间 控制 
3.  */  
4. public class QueueRuleUtil {  
5.       
6.     public static long getNextConsumeTime(int consumeCount) {  
7.         return getNextConsumeTime(consumeCount, 0);  
8.     }  
9.   
10.     public static long getNextConsumeSecond(int consumeCount) {  
11.         return getNextConsumeTime(consumeCount, 0);  
12.     }  
13.       
14.     public static long getNextConsumeTime(int cousumeCount, int addInteval) {  
15.         int secends = getNextConsumeSecond(cousumeCount,addInteval);  
16.         return System.currentTimeMillis()+secends*1000;  
17.     }  
18.       
19.     public static int getNextConsumeSecond(int cousumeCount, int addInteval) {  
20.         if (cousumeCount == 1) {  
21.             return  addInteval + 10;  
22.         } else if (cousumeCount == 2) {  
23.             return  addInteval + 60;  
24.         } else if (cousumeCount == 3) {  
25.             return  addInteval + 60 * 5;  
26.         } else if (cousumeCount == 4) {  
27.             return  addInteval + 60 * 15;  
28.         } else if (cousumeCount == 5) {  
29.             return addInteval + 60 * 60;  
30.         } else if (cousumeCount == 6){  
31.             return addInteval + 60 * 60 *2;  
32.         } else if(cousumeCount == 7){  
33.             return addInteval + 60 * 60 *5;  
34.         } else {  
35.             return addInteval + 60 * 60 * 10;  
36.         }  
37.     }  

除此之外，对于消费完成，等待删除的消息，可以将消息直接删除或者是进行备份。最好不要在该表中保留太多需要删除的消息，以免影响数据库的查询效率。

我们在处理消息的时候，首先对消息进行了锁定，设置了locker，如果系统出现异常的时候，也会产生消息一直处于被锁定的状态，此时可能还需要定期去修复被锁定的消息。

[java]  view plain  copy

1. /** 
2.      * 批量获取 可以消费的消息 
3.      *  
4.      * @param count 
5.      * @return 
6.      */  
7.     public void repairQueueByStatus(int status) {  
8.         List<QueueDO> activeList = null;  
9.         try {  
10.             Map<String,Object> params = new HashMap<String,Object>();  
11.             params.put("status", status);  
12.             //下次消费时间在当前时间3小时以内的消息  
13.                         params.put("next_consume_time", System.currentTimeMillis()+3*60*1000);  
14.             activeList =  queueDAO.findQueueByParams(params);  
15.         } catch (Exception e) {  
16.             logger.error("QueueDomainRepository.repairQueueByStatus find error occured!"  
17.                     + e.getMessage(), e);  
18.             throw new TuanRuntimeException(  
19.                     PayConstants.SERVICE_DATABASE_FALIURE,  
20.                     "QueueDomainRepository.findQueueByStatus error occured!",e);  
21.         }  
22.         if (activeList == null || activeList.size() == 0) {  
23.             return ;  
24.         }  
25.         for (QueueDO temp : activeList) {  
26.             try {  
27.                 //status=1，可被消费  
28.                                 queueDAO.update(temp.getQueueID(), PayConstants.QUEUE_STATUS_ACTIVE);  
29.             } catch (Exception e) {  
30.                 logger.error("QueueDomainRepository.repairQueueByStatus  update error occured!"  
31.                         + e.getMessage(), e);  
32.                 throw new TuanRuntimeException(  
33.                         PayConstants.SERVICE_DATABASE_FALIURE,  
34.                         "QueueDomainRepository.repairQueueByStatus update error occured!",e);  
35.             }  
36.               
37.         }  
38.          }  

以上就是对两种队列的简单说明。在使用基于数据库的队列的时候，其中还使用到了事件处理机制，这部分的内容，就下次的时候再去介绍。

优先队列的使用（点击打开链接）

我们知道优先队列其实内部实现就是一个堆的数据结构，java默认的是一个小跟堆，每次取出最小的元素，因为堆的性质他可以做到O(logn)级别的插入和删除操作。

我们知道堆的性质是有： 
1.堆中某个结点的值总是不大于（或不小于）其父结点的值； 
2.堆总是一棵完全二叉树。

将根结点最大的堆叫做大根堆，根结点最小的堆叫做小根堆。常见的堆有二叉堆、斐波那契堆等

插入：向堆中插入一个新元素；在数组的最末尾插入新结点。然后自下而上调整子结点与父结点：比较当前结点与父结点，不满足堆性质则交换，使得当前子树满足二叉堆的性质。时间复杂度为 O(logn)。

弹出：删除堆顶元素，再把堆存储的最后那个结点填在根结点处。再从上而下调整父结点与它的子结点。时间复杂度为 O(logn)。

删除：使该元素与堆尾元素交换，调整堆容量，再由原堆尾元素的当前位置自顶向下调整。时间复杂度为 O(logn)。

如果经常需要合并两个堆的操作，那么使用二项堆、斜堆、左偏树等数据结构会更好。 
可并堆支持合并操作，使得合并后的堆也能保持堆的性质。左偏树是可并堆的一种，保证左子树的深度大于右子树的深度，再用右子树与另一个堆合并。 
因此，堆支持查询最值、插入、删除操作。

堆排序，通过堆维护最值，对最值逐个弹出，使得得到的序列有序。 
下面看下一般的堆我们都直接用优先队列实现如下

import java.io.BufferedInputStream;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

class Dog
{
    public int x;
}
public class Main
{
    Scanner cin = new Scanner(new BufferedInputStream(System.in));
    Queue<Integer> queue = new PriorityQueue<>();///优先队列默认的小根堆
    void solve()
    {
        queue.add(5);
        queue.add(3);
        queue.add(56);
        while(!queue.isEmpty())
        {
            System.out.println(queue.poll());///维护一个堆保证每次取出的都是最小的并出堆
        }
        Comparator<Integer> cmp;///可以new一个重载器;
        cmp = new Comparator<Integer>()
        {
            public int compare(Integer e1,Integer e2)
            {
                return e2 - e1;///重载优先级使其变为大根堆
            }
        };
        Queue<Integer> que = new PriorityQueue<>(cmp);///筛入一个重载器使其变为大跟堆
        que.add(5);
        que.add(6);
        que.add(7);
        que.add(1);
        que.add(11);
        System.out.println("*****");
        while(!que.isEmpty())
        {
            System.out.println(que.poll());///维护一个堆保证每次取出的都是最大的并出堆
        }
        Comparator<Dog> dogcmp;
        dogcmp = new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.x-o2.x;///重载优先级使其变为小根堆
            }
        };
        Queue<Dog> q = new PriorityQueue<Dog>(dogcmp);
        Dog g = new Dog();
        g.x = 1;
        Dog g1 = new Dog();
        g1.x = 100;
        Dog g2 = new Dog();
        g2.x = 50;
        Dog g3 = new Dog();
        g3.x = 11;
        q.add(g);
        q.add(g1);
        q.add(g2);
        q.add(g3);
        System.out.println("*****");
        while(!q.isEmpty())
        {
            System.out.println(q.poll().x);///维护一个堆保证每次取出的都是最小的并出堆
        }
    }
    public static void main(String[] args)
    {
        new Main().solve();
    }
}