Home / Messaging / Fix ActiveMQ Slow Consumer

Messaging

Fix ActiveMQ Slow Consumer

Resolve ActiveMQ slow consumer issues by configuring prefetch limits, optimizing message processing, and adjusting consumer policies.

Published: Apr 3, 20267 min readBy FixWikiHub Editorial Team

Abstract illustration for a troubleshooting knowledge base category.

Introduction

ActiveMQ uses prefetch to batch messages to consumers for efficiency. When a consumer can't process its prefetch buffer fast enough, ActiveMQ marks it as a "slow consumer" and may reduce prefetch or warn about backlog buildup, affecting overall queue performance.

Symptoms

Slow consumer warning:

```bash $ tail -f /var/log/activemq/activemq.log

[WARN] Queue://orders.queue - Consumer Consumer:1 has been slow for 30000ms [WARN] Slow consumer detected: prefetch not being consumed ```

Queue backlog:

bash

[WARN] Queue depth exceeded 10000 messages due to slow consumer
[INFO] Prefetch for consumer Consumer:1 reduced from 1000 to 100

Consumer blocked:

bash

[ERROR] Consumer blocked waiting for acknowledge
[WARN] Message backlog growing, producers may be blocked

Common Causes

1.Prefetch too high - Consumer gets more messages than it can handle
2.Message processing slow - Complex business logic or database calls
3.Consumer resource limits - CPU, memory, or thread pool exhausted
4.Network latency - Slow network between broker and consumer
5.Blocking operations - Consumer does blocking I/O in message handler
6.Single-threaded consumer - Can't process concurrent messages

Step-by-Step Fix

Step 1: Identify Slow Consumers

```bash # List consumers for a queue curl -u admin:admin http://localhost:8161/api/jolokia/list/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue,consumer=*

# Check consumer statistics curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue/Consumers

# Via activemq-admin activemq-admin query --objname type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue --attribute ConsumerCount,QueueSize

# Check prefetch status curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue,consumer=Consumer:1/PrefetchSize ```

Step 2: Reduce Prefetch Size

```java // Set prefetch in connection factory ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); factory.getPrefetchPolicy().setQueuePrefetch(10); // Reduce from default 1000

// Or in connection URI ConnectionFactory factory = new ActiveMQConnectionFactory( "tcp://localhost:61616?jms.prefetchPolicy.queuePrefetch=10" );

// For specific consumer Queue queue = session.createQueue("orders.queue?consumer.prefetchSize=10"); MessageConsumer consumer = session.createConsumer(queue);

// Recommended prefetch values based on message processing time: // < 10ms per message: prefetch 100-1000 // 10-100ms per message: prefetch 10-50 // > 100ms per message: prefetch 1-10 ```

Step 3: Configure Consumer Priority

```xml  <policyEntry queue="orders.queue" prioritizedMessages="true" useConsumerPriority="true" strictOrderDispatch="true"> <dispatchPolicy> <strictOrderDispatchPolicy/> </dispatchPolicy> </policyEntry>

```

```java // Set consumer priority Queue queue = session.createQueue("orders.queue?consumer.priority=10"); MessageConsumer consumer = session.createConsumer(queue);

// Priority ranges from 0-127 // Higher priority = more messages dispatched ```

Step 4: Optimize Message Processing

```java // Before: Slow single-threaded processing MessageConsumer consumer = session.createConsumer(queue); consumer.setMessageListener(message -> { processMessage(message); // Blocking, slow operation session.commit(); });

// After: Parallel processing with thread pool ExecutorService executor = Executors.newFixedThreadPool(10); consumer.setMessageListener(message -> { executor.submit(() -> { processMessage(message); session.commit(); }); });

// Or use Spring's DefaultMessageListenerContainer @Bean public DefaultMessageListenerContainer jmsContainer() { DefaultMessageListenerContainer container = new DefaultMessageListenerContainer(); container.setConnectionFactory(connectionFactory()); container.setDestinationName("orders.queue"); container.setConcurrentConsumers(10); // Multiple concurrent consumers container.setMaxConcurrentConsumers(20); container.setSessionTransacted(true); return container; } ```

Step 5: Check Consumer Resource Usage

```bash # Check consumer process CPU top -p <consumer_pid> ps -p <consumer_pid> -o %cpu,%mem,vsz,rss

# Check thread count ps -eLf | grep <consumer_pid> | wc -l

# Check open connections lsof -p <consumer_pid> | grep TCP

# Check JVM memory (for Java consumers) jstat -gc <consumer_pid> jcmd <consumer_pid> GC.heap_info

# If resources exhausted, scale consumers or optimize processing ```

Step 6: Use Async Message Processing

```java // Use async acknowledgment Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

// Or client acknowledgment for explicit control Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(queue); Message message = consumer.receive(); // Process message asynchronously executor.submit(() -> { processMessage(message); message.acknowledge(); // Acknowledge after processing }); ```

Step 7: Configure Abort Slow Consumers

```xml  <policyEntry queue=">" abortSlowConsumerThreshold="30000" abortSlowConsumerStrategy="abort"> <slowConsumerStrategy> <abortSlowConsumerStrategy abortConnection="true"/> </slowConsumerStrategy> </policyEntry>

<policyEntry queue=">" reduceSlowConsumerPrefetch="true" slowConsumerPrefetchReductionFactor="0.5"> <slowConsumerStrategy> <prefetchSlowConsumerStrategy/> </slowConsumerStrategy> </policyEntry> ```

Step 8: Monitor Consumer Lag

```bash # Check dispatch queue size curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue,consumer=Consumer:1/DispatchedQueueSize

# Check dequeued vs acknowledged ratio curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue/DequeueCount curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue,consumer=Consumer:1/AcknowledgeCount

# If dequeued >> acknowledged, consumer is slow

# Monitor processing time # Add timing to consumer code: long start = System.currentTimeMillis(); processMessage(message); long elapsed = System.currentTimeMillis() - start; log.info("Processing time: {} ms", elapsed); ```

Step 9: Scale Consumer Count

```bash # Check current consumer count curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue/ConsumerCount

# Add more consumers # Java: Use concurrent consumers DefaultMessageListenerContainer container = new DefaultMessageListenerContainer(); container.setConcurrentConsumers(5); container.setMaxConcurrentConsumers(20);

# Or deploy multiple consumer instances # Kubernetes: Scale consumer deployment kubectl scale deployment order-consumer --replicas=10

# Ensure consumers share same queue for load balancing ```

Step 10: Check Network Performance

```bash # Test network latency to broker ping activemq-host

# Check TCP connection stats netstat -i

# Measure message throughput # On broker: activemq-admin query --objname type=Broker --attribute TotalMessageCount,TotalDequeueCount

# Monitor connection bandwidth iftop -i eth0

# If high latency, increase prefetch and reduce acknowledgments # Or move consumers closer to broker ```

Consumer Performance Settings

Setting	Default	Slow Consumer Recommended
prefetchPolicy.queuePrefetch	1000	10-100
concurrentConsumers	1	5-20
abortSlowConsumerThreshold	0 (disabled)	30000ms
consumer.priority	0	Higher for fast consumers

Verification

```bash # After configuration changes # Restart consumers

# Check consumer dispatch rate curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue/DequeueCount

# Watch for slow consumer warnings tail -f /var/log/activemq/activemq.log | grep -i "slow consumer"

# Should show no warnings

# Check queue depth curl -u admin:admin http://localhost:8161/api/jolokia/read/org.apache.activemq:type=Broker,brokerName=localhost,destinationType=Queue,destinationName=orders.queue/QueueSize

# Should be stable or decreasing

# Monitor consumer statistics activemq-admin query --objname type=Broker,destinationType=Queue --attribute QueueSize,ConsumerCount,DequeueCount ```

Prevention

To prevent ActiveMQ slow consumer issues from recurring, implement these proactive measures:

1. Monitor Consumer Performance

yaml

groups:
- name: activemq-consumers
  rules:
  - alert: ActiveMQSlowConsumer
    expr: |
      activemq_queue_consumer_dispatch_rate < 10
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "ActiveMQ consumer dispatch rate below 10 msg/s"

2. Configure Abort Slow Consumer

xml

<!-- activemq.xml -->
<destinationPolicy>
  <policyMap>
    <policyEntries>
      <policyEntry queue=">" 
                   slowConsumerThreshold="30000"
                   slowConsumerCheckPeriod="60000"
                   abortSlowConsumer="true">
        <slowConsumerStrategy>
          <abortSlowConsumerStrategy abortConnection="false"/>
        </slowConsumerStrategy>
      </policyEntry>
    </policyEntries>
  </policyMap>
</destinationPolicy>

3. Optimize Prefetch Settings

xml

<!-- ActiveMQ connection factory configuration -->
<bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
  <property name="brokerURL" value="tcp://localhost:61616"/>
  <property name="prefetchPolicy">
    <bean class="org.apache.activemq.ActiveMQPrefetchPolicy">
      <property name="queuePrefetch" value="100"/>
      <property name="topicPrefetch" value="100"/>
    </bean>
  </property>
</bean>

Best Practices Checklist

[ ] Monitor consumer dispatch rate
[ ] Configure abort slow consumer
[ ] Optimize prefetch settings
[ ] Scale consumers horizontally
[ ] Monitor queue depth
[ ] Test consumer failover

[Fix ActiveMQ Destination Full](/articles/fix-activemq-destination-full)
[Fix ActiveMQ Master Slave Failover](/articles/fix-activemq-master-slave-failover)
[Fix RabbitMQ Consumer Timeout](/articles/fix-rabbitmq-consumer-timeout)

[Fix Fix Activemq Broker Down Issue in Messaging](fix-activemq-broker-down)
[Fix ActiveMQ Destination Full](fix-activemq-destination-full)
[Fix ActiveMQ JDBC Lock Expired](fix-activemq-jdbc-lock-expired)
[Fix ActiveMQ Kaha PIndex Corrupted](fix-activemq-kaha-pindex-corrupted)
[Fix ActiveMQ Master Slave Failover](fix-activemq-master-slave-failover)

Was this guide helpful?

Related search paths

People also search for

If the symptom is close but not identical, these search paths usually surface the right neighboring fixes faster than scrolling the full archive.

ActiveMQ Slow Consumer ActiveMQ Slow Consumer Messaging ActiveMQ Slow Consumer troubleshooting ActiveMQ Slow Consumer fix Resolve ActiveMQ slow consumer issues by configuring prefetch limits, optimizing message processing, and adjusting consumer policies Messaging Resolve ActiveMQ slow consumer issues by configuring prefetch limits, optimizing message processing, and adjusting consumer policies

Explore Related Topics

Browse Guides from Other Categories

Discover troubleshooting guides from related categories to expand your knowledge.

FAQ

Messaging Troubleshooting FAQs

Common questions about troubleshooting and preventing similar issues

How do I know if this messaging-errors troubleshooting guide applies to my situation?

This guide is designed for messaging-errors issues. If you're experiencing similar symptoms described in the article, follow the step-by-step instructions. Start with the most common causes and work through the diagnostic process.

Is it safe to follow these messaging-errors troubleshooting steps?

Yes, all steps are designed to be safe and non-destructive. We recommend creating backups before making significant changes and testing each step before proceeding to the next.

How long does it typically take to resolve this type of messaging-errors issue?

Most messaging-errors issues can be resolved within 30 minutes to 2 hours, depending on the complexity and root cause. Follow the troubleshooting flow to identify and fix the problem efficiently.

How can I prevent this messaging-errors issue from happening again?

Regular maintenance, monitoring, and following best practices for messaging-errors configuration can help prevent recurrence. Consider implementing automated checks and alerts for early detection.

Written by

FixWikiHub Editorial Team

Our editorial team consists of experienced DevOps engineers, systems administrators, and cloud architects with hands-on experience in production environments across AWS, Azure, GCP, and on-premises infrastructure.

Every guide undergoes technical review for accuracy and is updated when software versions, commands, or best practices change.

Last updated: Apr 3, 2026

About our team

Important Notice

Disclaimer & Safety Guidelines

The troubleshooting steps in this guide are provided for educational and informational purposes. Before applying any changes to production systems:

Test in a staging environment first — Always verify commands and configurations in a non-production environment before deploying to live systems.
Create backups — Ensure you have current backups of databases, configurations, and critical files before making changes.
Understand the impact — Review how each step may affect your specific environment, dependencies, and users.
Consult official documentation — This guide supplements, but does not replace, official vendor documentation and best practices.

FixWikiHub is not responsible for any damages arising from the use of this content. See our Terms of Use for more information.

Resources

Official Documentation & Further Reading

For authoritative information, consult the official documentation for the technologies discussed in this guide. Our troubleshooting content supplements, but does not replace, vendor documentation.

AWS Documentation — Official Amazon Web Services guides and API references
Kubernetes Documentation — Official Kubernetes documentation
Nginx Documentation — Official Nginx web server documentation
Apache Documentation — Official Apache HTTP Server documentation
Docker Documentation — Official Docker container documentation

Fix ActiveMQ Slow Consumer

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Identify Slow Consumers

Step 2: Reduce Prefetch Size

Step 3: Configure Consumer Priority

Step 4: Optimize Message Processing

Step 5: Check Consumer Resource Usage

Step 6: Use Async Message Processing

Step 7: Configure Abort Slow Consumers

Step 8: Monitor Consumer Lag

Step 9: Scale Consumer Count

Step 10: Check Network Performance

Consumer Performance Settings

Verification

Prevention

1. Monitor Consumer Performance

2. Configure Abort Slow Consumer

3. Optimize Prefetch Settings

Best Practices Checklist

People also search for

Browse Guides from Other Categories

WordPress

SSL

DNS

Messaging Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading

Fix ActiveMQ Slow Consumer

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Identify Slow Consumers

Step 2: Reduce Prefetch Size

Step 3: Configure Consumer Priority

Step 4: Optimize Message Processing

Step 5: Check Consumer Resource Usage

Step 6: Use Async Message Processing

Step 7: Configure Abort Slow Consumers

Step 8: Monitor Consumer Lag

Step 9: Scale Consumer Count

Step 10: Check Network Performance

Consumer Performance Settings

Verification

Prevention

1. Monitor Consumer Performance

2. Configure Abort Slow Consumer

3. Optimize Prefetch Settings

Best Practices Checklist

Related Issues

Related Articles

People also search for

Share this guide

More Messaging Troubleshooting Guides

Browse Guides from Other Categories

Messaging Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading