Modèle des consommateurs concurrents
Implémentez le modèle des consommateurs concurrents pour permettre à plusieurs consommateurs de traiter les messages d’une même file. Augmentez votre capacité de traitement en ajoutant d’autres consommateurs.
Modèle des consommateurs concurrents est une leçon RabbitMQ Messaging & Async Systems gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage RabbitMQ Messaging & Async Systems, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours RabbitMQ Messaging & Async Systems comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
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!
Apprends RabbitMQ Messaging & Async Systems avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 11
- Leçons
- 44
Questions Fréquemment Posées
La leçon « Modèle des consommateurs concurrents » est-elle gratuite ?
Oui — le texte complet de « Modèle des consommateurs concurrents » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours RabbitMQ Messaging & Async Systems, passe à CoddyKit PRO. Le cours RabbitMQ Messaging & Async Systems comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Modèle des consommateurs concurrents » ?
Implémentez le modèle des consommateurs concurrents pour permettre à plusieurs consommateurs de traiter les messages d’une même file. Augmentez votre capacité de traitement en ajoutant d’autres conso… Tu pratiques RabbitMQ Messaging & Async Systems avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer RabbitMQ Messaging & Async Systems ?
Aucune expérience préalable n'est requise. RabbitMQ Messaging & Async Systems sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Modèle des consommateurs concurrents » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon RabbitMQ Messaging & Async Systems ?
Oui. Chaque leçon RabbitMQ Messaging & Async Systems inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Modèle des consommateurs concurrents
- Nombre de messages préchargés (QoS)
- Consommateurs exclusifs et priorité des consommateurs
- Consommateur actif unique