ActiveMQ queue 分页

分页：即获取部分数据，queue按页从message cursor读取消息，然后分发给consumer。

页大小：

public abstract class BaseDestination implements Destination {
    /**
     * The maximum number of messages to page in to the destination from
     * persistent storage
     */
    public static final int MAX_PAGE_SIZE = 200;
}

存放分页消息的数据结构：

public class Queue extends BaseDestination implements Task, UsageListener {
    // message cursor，可视为消息的数据源
    protected PendingMessageCursor messages;
    // 所有的分页消息
    private final PendingList pagedInMessages = new OrderedPendingList();
    // 剩余的没有dispatch的分页消息
    protected PendingList pagedInPendingDispatch = new OrderedPendingList();
}

把消息添加到分页中：

protected void pageInMessages(boolean force) throws Exception {
    doDispatch(doPageInForDispatch(force, true));
}

 private PendingList doPageInForDispatch(boolean force, boolean processExpired) throws Exception {
     List<QueueMessageReference> result = null;
     PendingList resultList = null;

     // 根据maxPageSize和message cursor中的大小，决定需要读取的消息数量
     int toPageIn = Math.min(getMaxPageSize(), messages.size());
     int pagedInPendingSize = 0;
     pagedInPendingDispatchLock.readLock().lock();
     try {
         pagedInPendingSize = pagedInPendingDispatch.size();
     } finally {
         pagedInPendingDispatchLock.readLock().unlock();
     }

     LOG.debug("{} toPageIn: {}, Inflight: {}, pagedInMessages.size {}, pagedInPendingDispatch.size {}, enqueueCount: {}, dequeueCount: {}, memUsage:{}",
             new Object[]{
                     destination.getPhysicalName(),
                     toPageIn,
                     destinationStatistics.getInflight().getCount(),
                     pagedInMessages.size(),
                     pagedInPendingSize,
                     destinationStatistics.getEnqueues().getCount(),
                     destinationStatistics.getDequeues().getCount(),
                     getMemoryUsage().getUsage()
             });
     if (isLazyDispatch() && !force) {
         // Only page in the minimum number of messages which can be
         // dispatched immediately.
         toPageIn = Math.min(getConsumerMessageCountBeforeFull(), toPageIn);
     }
     if (toPageIn > 0 && (force || (!consumers.isEmpty() && pagedInPendingSize < getMaxPageSize()))) {
         int count = 0;
         result = new ArrayList<QueueMessageReference>(toPageIn);
         messagesLock.writeLock().lock();
         try {
             try {
                 messages.setMaxBatchSize(toPageIn);
                 messages.reset();
                 while (messages.hasNext() && count < toPageIn) {
                     MessageReference node = messages.next();
                     messages.remove();

                     QueueMessageReference ref = createMessageReference(node.getMessage());
                     if (processExpired && ref.isExpired()) {
                         if (broker.isExpired(ref)) {
                             messageExpired(createConnectionContext(), ref);
                         } else {
                             ref.decrementReferenceCount();
                         }
                     } else {
                         // 添加QueueMessageReference到result中
                         result.add(ref);
                         count++;
                     }
                 }
             } finally {
                 messages.release();
             }
         } finally {
             messagesLock.writeLock().unlock();
         }
         // Only add new messages, not already pagedIn to avoid multiple
         // dispatch attempts
         pagedInMessagesLock.writeLock().lock();
         try {
             if(isPrioritizedMessages()) {
                 resultList = new PrioritizedPendingList();
             } else {
                 resultList = new OrderedPendingList();
             }
             for (QueueMessageReference ref : result) {
                 if (!pagedInMessages.contains(ref)) {
                     //分别添加QueueMessageReference到 pagedInMessages 和 resultList
                     //resultList作为返回值，直接传递给doDispatch(PendingList list)，
                     //在doDispatch中，分发给消费者后，就会从 resultList 中删除，
                     pagedInMessages.addMessageLast(ref);
                     resultList.addMessageLast(ref);
                 } else {
                     ref.decrementReferenceCount();
                     // store should have trapped duplicate in it's index, also cursor audit
                     // we need to remove the duplicate from the store in the knowledge that the original message may be inflight
                     // note: jdbc store will not trap unacked messages as a duplicate b/c it gives each message a unique sequence id
                     LOG.warn("{}, duplicate message {} paged in, is cursor audit disabled? Removing from store and redirecting to dlq", this, ref.getMessage());
                     if (store != null) {
                         ConnectionContext connectionContext = createConnectionContext();
                         store.removeMessage(connectionContext, new MessageAck(ref.getMessage(), MessageAck.POSION_ACK_TYPE, 1));
                         broker.getRoot().sendToDeadLetterQueue(connectionContext, ref.getMessage(), null, new Throwable("duplicate paged in from store for " + destination));
                     }
                 }
             }
         } finally {
             pagedInMessagesLock.writeLock().unlock();
         }
     } else {
         // Avoid return null list, if condition is not validated
         resultList = new OrderedPendingList();
     }

     return resultList;
 }

 //分发消息
 private void doDispatch(PendingList list) throws Exception {
     boolean doWakeUp = false;

     pagedInPendingDispatchLock.writeLock().lock();
     try {
         //存在需要重新发送的消息
         if (!redeliveredWaitingDispatch.isEmpty()) {
             // Try first to dispatch redelivered messages to keep an
             // proper order
             redeliveredWaitingDispatch = doActualDispatch(redeliveredWaitingDispatch);
         }
         //存在没有分发的分页消息
         if (!pagedInPendingDispatch.isEmpty()) {
             // Next dispatch anything that had not been
             // dispatched before.
             pagedInPendingDispatch = doActualDispatch(pagedInPendingDispatch);
         }
         // and now see if we can dispatch the new stuff.. and append to
         // the pending
         // list anything that does not actually get dispatched.
         if (list != null && !list.isEmpty()) {
             if (pagedInPendingDispatch.isEmpty()) {
                 //doActualDispatch进行实际的分发消息：
                 //分发给消费者的消息，会从list中删除，list中保存剩下的消息，doActualDispatch返回list
                 pagedInPendingDispatch.addAll(doActualDispatch(list));
             } else {
                 for (MessageReference qmr : list) {
                     if (!pagedInPendingDispatch.contains(qmr)) {
                         pagedInPendingDispatch.addMessageLast(qmr);
                     }
                 }
                 doWakeUp = true;
             }
         }
     } finally {
         pagedInPendingDispatchLock.writeLock().unlock();
     }

     if (doWakeUp) {
         // avoid lock order contention
         asyncWakeup();
     }
 }

 // 实际分发消息
 private PendingList doActualDispatch(PendingList list) throws Exception {
     List<Subscription> consumers;
     consumersLock.writeLock().lock();

     try {
         if (this.consumers.isEmpty()) {
             // slave dispatch happens in processDispatchNotification
             return list;
         }
         consumers = new ArrayList<Subscription>(this.consumers);
     } finally {
         consumersLock.writeLock().unlock();
     }

     Set<Subscription> fullConsumers = new HashSet<Subscription>(this.consumers.size());

     for (Iterator<MessageReference> iterator = list.iterator(); iterator.hasNext();) {

         MessageReference node = iterator.next();
         Subscription target = null;
         for (Subscription s : consumers) {
             if (s instanceof QueueBrowserSubscription) {
                 continue;
             }
             if (!fullConsumers.contains(s)) {
                 if (!s.isFull()) {
                     if (dispatchSelector.canSelect(s, node) && assignMessageGroup(s, (QueueMessageReference)node) && !((QueueMessageReference) node).isAcked() ) {
                         // Dispatch it.
                         s.add(node);
                         LOG.trace("assigned {} to consumer {}", node.getMessageId(), s.getConsumerInfo().getConsumerId());
                         //从list中删除
                         iterator.remove();
                         target = s;
                         break;
                     }
                 } else {
                     // no further dispatch of list to a full consumer to
                     // avoid out of order message receipt
                     fullConsumers.add(s);
                     LOG.trace("Subscription full {}", s);
                 }
             }
         }

         if (target == null && node.isDropped()) {
             iterator.remove();
         }

         // return if there are no consumers or all consumers are full
         if (target == null && consumers.size() == fullConsumers.size()) {
             return list;
         }

         // If it got dispatched, rotate the consumer list to get round robin
         // distribution.
         if (target != null && !strictOrderDispatch && consumers.size() > 1
                 && !dispatchSelector.isExclusiveConsumer(target)) {
             consumersLock.writeLock().lock();
             try {
                 if (removeFromConsumerList(target)) {
                     addToConsumerList(target);
                     consumers = new ArrayList<Subscription>(this.consumers);
                 }
             } finally {
                 consumersLock.writeLock().unlock();
             }
         }
     }

     return list;
 }