RabbitMQ Messaging & Async Systems · Lektion

Muster konkurrierender Consumer

Muster konkurrierender Consumer ist eine kostenlose RabbitMQ Messaging & Async Systems-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des RabbitMQ Messaging & Async Systems-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der RabbitMQ Messaging & Async Systems-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Scaling with Competing Consumers

Welcome! In distributed systems, you often need to process many tasks efficiently. The Competing Consumers pattern is a powerful way to achieve this.

It allows you to scale your message processing capacity by simply adding more workers.

How Competing Consumers Work

Imagine a single queue of tasks. Instead of one worker taking all tasks, multiple workers (consumers) listen to this same queue.

Each message is delivered to only one of the competing consumers.
Consumers "compete" to receive the next available message.
This distributes the workload automatically.

Key Benefits of the Pattern

The Competing Consumers pattern offers several advantages:

Scalability: Easily increase processing power by adding more consumer instances.
Reliability: If one consumer fails, others can pick up its share of messages.
Load Balancing: Messages are spread across available consumers, balancing the workload.
Decoupling: Producers don't need to know how many consumers there are or where they are.

Producer: Sending Tasks

Let's set up a basic producer that sends messages (tasks) to a queue named task_queue. Each message will be a simple string.

Run this code to send a few messages:

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class TaskProducer {
    private final static String QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost"); // Assuming RabbitMQ is local

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // Declare a durable queue
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);

            for (int i = 0; i < 10; i++) {
                String message = "Task " + (i + 1);
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
                System.out.println(" [x] Sent '" + message + "'");
                Thread.sleep(100); // Small delay to visualize
            }
        }
    }
}

Consumer 1: Processing Tasks

Now, let's create our first consumer. It will connect to task_queue and start processing messages. Each message will be acknowledged after simulating work.

Run this consumer in a terminal:

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

public class TaskConsumer {
    private final static String QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        System.out.println(" [*] Consumer 1 waiting for messages.");

        // Basic QoS: Prefetch 1 message at a time to ensure fair dispatch
        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [C1] Received '" + message + "'");
            try {
                Thread.sleep(1000); // Simulate work
            } finally {
                System.out.println(" [C1] Done '" + message + "'");
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> {});
    }
}

Running Multiple Consumers

To truly see the competing consumers pattern in action, open a new terminal window and run the exact same TaskConsumer code again.

You'll now have two consumer instances listening to the task_queue. Run the producer code (from Scene 4) once more. Observe how messages are now distributed between both consumer instances, demonstrating how they compete for messages and share the workload!

RabbitMQ's Dispatching Logic

By default, RabbitMQ uses a round-robin dispatching mechanism when multiple consumers are connected to the same queue. This means messages are sent to consumers sequentially.

Consumer 1 gets message 1.
Consumer 2 gets message 2.
Consumer 1 gets message 3, and so on.

The basicQos(1) setting in our consumer code is crucial here. It tells RabbitMQ not to send more than one unacknowledged message to a consumer at a time, ensuring fair dispatch even if consumers process at different speeds.

Common Use Cases

The Competing Consumers pattern is ideal for scenarios like:

Image processing: Multiple workers resizing images from a queue.
Email sending: Sending bulk emails without overwhelming a single service.
Log processing: Analyzing large volumes of logs in parallel.
Background jobs: Any task that can be processed independently by multiple workers.

Important Considerations

When using competing consumers, keep these in mind:

Message Ordering: If strict message order is critical, this pattern might not be suitable directly, as messages can be processed out of order by different consumers.
Idempotency: Consumers should ideally be idempotent. This means processing the same message multiple times should have the same effect as processing it once. This is vital for fault tolerance and retries.

Competing Consumers Quiz

Test your understanding of the Competing Consumers pattern.

Recap: Competing Consumers

Great job! You've learned about the Competing Consumers pattern:

It enables multiple consumers to process messages from a single queue.
It's excellent for scaling and load balancing message processing.
RabbitMQ's default round-robin dispatch and QoS settings facilitate fair distribution.
Consider idempotency and potential out-of-order processing for specific use cases.

Next, we'll dive deeper into optimizing consumer efficiency with prefetch counts!

Häufig gestellte Fragen

Ist die Lektion „Muster konkurrierender Consumer“ kostenlos?

Ja — der vollständige Text von „Muster konkurrierender Consumer“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des RabbitMQ Messaging & Async Systems-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der RabbitMQ Messaging & Async Systems-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Muster konkurrierender Consumer“?

Implementieren Sie das Muster konkurrierender Consumer, damit mehrere Consumer Nachrichten aus einer einzelnen Queue verarbeiten können. Skalieren Sie Ihre Verarbeitungskapazität durch das Hinzufügen… Du übst RabbitMQ Messaging & Async Systems mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um RabbitMQ Messaging & Async Systems zu starten?

Keine Vorkenntnisse erforderlich. RabbitMQ Messaging & Async Systems auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Muster konkurrierender Consumer“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser RabbitMQ Messaging & Async Systems-Lektion Code schreiben und ausführen?

Ja. Jede RabbitMQ Messaging & Async Systems-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Muster konkurrierender Consumer
Prefetch Count (QoS)
Exklusive Consumer und Consumer-Priorität
Single Active Consumer

← Zurück zu RabbitMQ Messaging & Async Systems