private boolean noHigherPriorityWithCredit(final QueueConsumer<?,?> sub, final QueueEntry queueEntry) { Iterator<QueueConsumer<?,?>> consumerIterator = _queueConsumerManager.getAllIterator(); while (consumerIterator.hasNext()) { QueueConsumer<?,?> consumer = consumerIterator.next(); if(consumer.getPriority() > sub.getPriority()) { if(consumer.isNotifyWorkDesired() && consumer.acquires() && consumer.hasInterest(queueEntry) && getNextAvailableEntry(consumer) != null) { return false; } } else { break; } } return true; }
@Override public boolean acquire(MessageInstanceConsumer<?> consumer) { final boolean acquired = acquire(((QueueConsumer<?,?>) consumer).getOwningState().getUnstealableState()); if(acquired) { _deliveryCountUpdater.compareAndSet(this,-1,0); } return acquired; }
@Override public boolean setNotified(final QueueConsumer<?,?> consumer, final boolean notified) { QueueConsumerNode node = consumer.getQueueConsumerNode(); if (consumer.acquires()) { if (notified) { return node.moveFromTo(INTERESTED, NodeState.NOTIFIED); } else { return node.moveFromTo(NOTIFIED, NodeState.INTERESTED); } } else { return true; } }
private void removeFromAll(final QueueConsumer<?,?> consumer) { final QueueConsumerNode node = consumer.getQueueConsumerNode(); int consumerPriority = consumer.getPriority(); for (int i = 0; i < _allConsumers.size(); ++i) { final PriorityConsumerListPair priorityConsumerListPair = _allConsumers.get(i); if (priorityConsumerListPair._priority == consumerPriority) { priorityConsumerListPair._consumers.removeEntry(node.getAllEntry()); if (priorityConsumerListPair._consumers.isEmpty()) { _allConsumers.remove(i); _notified.remove(i); _interested.remove(i); } return; } else if (priorityConsumerListPair._priority < consumerPriority) { break; } } }
boolean subActive = sub.isActive() && !sub.isSuspended(); && (sub.getPriority() == Integer.MAX_VALUE || noHigherPriorityWithCredit(sub, node))) if (sub.allocateCredit(node)) if ((sub.acquires() && !assign(sub, node)) || (!sub.acquires() && (messageReference = node.newMessageReference()) == null)) sub.restoreCredit(node); sub.awaitCredit(node);
if (!consumer.isSuspended()) if (consumer.acquires()) consumer.noMessagesAvailable(); messageContainer = null; consumer.flushBatched();
@Override public void addConsumer(final QueueConsumer<?,?> consumer) { QueueConsumerNode node = new QueueConsumerNode(this, consumer); consumer.setQueueConsumerNode(node); addToAll(node); if (consumer.isNotifyWorkDesired()) { if (consumer.acquires()) { node.moveFromTo(REMOVED, NodeState.INTERESTED); } else { node.moveFromTo(REMOVED, NodeState.NON_ACQUIRING); } } else { node.moveFromTo(REMOVED, NodeState.NOT_INTERESTED); } _count++; }
@Override public int getHighestNotifiedPriority() { final Iterator<QueueConsumerNode> notifiedIterator = new PrioritisedQueueConsumerNodeIterator(_notified); if(notifiedIterator.hasNext()) { final QueueConsumerNode queueConsumerNode = notifiedIterator.next(); return queueConsumerNode.getQueueConsumer().getPriority(); } else { return Integer.MIN_VALUE; } }
private boolean mightAssign(final QueueConsumer sub, final QueueEntry entry) { return _messageGroupManager == null || !sub.acquires() || _messageGroupManager.mightAssign(entry, sub); }
@Override public QueueEntry findEarliestAssignedAvailableEntry(QueueConsumer<?,?> sub) { EntryFinder visitor = new EntryFinder(sub); sub.getQueue().visit(visitor); return visitor.getEntry(); }
@Override public boolean removeConsumer(final QueueConsumer<?,?> consumer) { removeFromAll(consumer); QueueConsumerNode node = consumer.getQueueConsumerNode(); if (node.moveFromTo(STATES_OTHER_THAN_REMOVED, NodeState.REMOVED)) { _count--; return true; } return false; }
@Override public boolean acquireOrSteal(final Runnable delayedAcquisitionTask) { boolean acquired = acquire(); if(!acquired) { QueueConsumer<?,?> consumer = getAcquiringConsumer(); acquired = removeAcquisitionFromConsumer(consumer); if(acquired) { consumer.acquisitionRemoved(this); } else if(delayedAcquisitionTask != null) { DelayedAcquisitionStateListener listener = new DelayedAcquisitionStateListener(delayedAcquisitionTask); addStateChangeListener(listener); if(acquireOrSteal(null)) { listener.runTask(); } } } return acquired; }
Queue<?> queue = (Queue<?>)((QueueConsumer<?,?>)configuredObject).getParent(); setQueueProperties(queue, properties);
void setNotifyWorkDesired(final QueueConsumer consumer, final boolean desired) { if (_queueConsumerManager.setInterest(consumer, desired)) { if (desired) { _activeSubscriberCount.incrementAndGet(); notifyConsumer(consumer); } else { _activeSubscriberCount.decrementAndGet(); // iterate over interested and notify one as long as its priority is higher than any notified final Iterator<QueueConsumer<?,?>> consumerIterator = _queueConsumerManager.getInterestedIterator(); final int highestNotifiedPriority = _queueConsumerManager.getHighestNotifiedPriority(); while (consumerIterator.hasNext()) { QueueConsumer<?,?> queueConsumer = consumerIterator.next(); if (queueConsumer.getPriority() < highestNotifiedPriority || notifyConsumer(queueConsumer)) { break; } } } } }
private boolean consumerHasAvailableMessages(final QueueConsumer consumer) { final QueueEntry queueEntry; return !consumer.acquires() || ((queueEntry = getNextAvailableEntry(consumer)) != null && noHigherPriorityWithCredit(consumer, queueEntry)); }
@Override public synchronized QueueEntry findEarliestAssignedAvailableEntry(final QueueConsumer<?,?> sub) { EntryFinder visitor = new EntryFinder(sub); sub.getQueue().visit(visitor); return visitor.getEntry(); }
@Override public boolean setInterest(final QueueConsumer<?,?> consumer, final boolean interested) { QueueConsumerNode node = consumer.getQueueConsumerNode(); if (interested) { if (consumer.acquires()) { return node.moveFromTo(NOT_INTERESTED, NodeState.INTERESTED); } else { return node.moveFromTo(NOT_INTERESTED, NodeState.NON_ACQUIRING); } } else { if (consumer.acquires()) { return node.moveFromTo(EITHER_INTERESTED_OR_NOTIFIED, NodeState.NOT_INTERESTED); } else { return node.moveFromTo(NON_ACQUIRING, NodeState.NOT_INTERESTED); } } }
private void addToAll(final QueueConsumerNode consumerNode) { int consumerPriority = consumerNode.getQueueConsumer().getPriority(); int i; for (i = 0; i < _allConsumers.size(); ++i) { final PriorityConsumerListPair priorityConsumerListPair = _allConsumers.get(i); if (priorityConsumerListPair._priority == consumerPriority) { final QueueConsumerNodeListEntry entry = priorityConsumerListPair._consumers.add(consumerNode); consumerNode.setAllEntry(entry); return; } else if (priorityConsumerListPair._priority < consumerPriority) { break; } } PriorityConsumerListPair newPriorityConsumerListPair = new PriorityConsumerListPair(consumerPriority); final QueueConsumerNodeListEntry entry = newPriorityConsumerListPair._consumers.add(consumerNode); consumerNode.setAllEntry(entry); _allConsumers.add(i, newPriorityConsumerListPair); _notified.add(i, new PriorityConsumerListPair(consumerPriority)); _interested.add(i, new PriorityConsumerListPair(consumerPriority)); }
for (PriorityConsumerListPair pair : _interested) if (pair._priority == queueConsumerNode.getQueueConsumer().getPriority()) for (PriorityConsumerListPair pair : _notified) if (pair._priority == queueConsumerNode.getQueueConsumer().getPriority())