RabbitMQ Messaging & Async Systems · 강의

경쟁 소비자 패턴

여러 소비자가 하나의 큐에서 메시지를 처리할 수 있도록 경쟁 소비자 패턴을 구현합니다. 소비자를 추가하여 처리 용량을 확장합니다.

레슨 1/411개 단계

경쟁 소비자 패턴은(는) CoddyKit의 무료 RabbitMQ Messaging & Async Systems 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 RabbitMQ Messaging & Async Systems 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. RabbitMQ Messaging & Async Systems 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

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!

무료로 시작

AI 튜터와 함께 RabbitMQ Messaging & Async Systems을(를) 배우세요 — 무료

브라우저에서 실제 코드를 작성하고 실행하며, 24/7 AI 튜터로부터 즉각적인 도움을 받고, 웹이나 앱에서 중단한 부분부터 계속 학습하세요.

코스: 11
레슨: 44

무료로 학습 시작 전체 코스 보기

자주 묻는 질문

“경쟁 소비자 패턴” 강의는 무료인가요?

네 — “경쟁 소비자 패턴” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 RabbitMQ Messaging & Async Systems 강의 전체를 잠금 해제할 수 있습니다. RabbitMQ Messaging & Async Systems 강의에는 총 4개의 강의가 포함되어 있습니다.

“경쟁 소비자 패턴”에서 뭘 배우나요?

여러 소비자가 하나의 큐에서 메시지를 처리할 수 있도록 경쟁 소비자 패턴을 구현합니다. 소비자를 추가하여 처리 용량을 확장합니다. 브라우저에서 직접 실행하는 실습 코드로 RabbitMQ Messaging & Async Systems을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

RabbitMQ Messaging & Async Systems을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 RabbitMQ Messaging & Async Systems은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“경쟁 소비자 패턴” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 RabbitMQ Messaging & Async Systems 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 RabbitMQ Messaging & Async Systems 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← RabbitMQ Messaging & Async Systems(으)로 돌아가기