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;
}