RabbitMQ: meddelelser og asynkrone systemer · Lektion

Arbejdskøer: Fair fordeling

Implementér arbejdskøer for at fordele opgaver mellem flere forbrugere ved hjælp af en round-robin-fordelingsstrategi. Lær at behandle tidskrævende opgaver asynkront.

Lektion 2 af 411 trin

Arbejdskøer: Fair fordeling er en gratis RabbitMQ: meddelelser og asynkrone systemer-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i RabbitMQ: meddelelser og asynkrone systemer, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. RabbitMQ: meddelelser og asynkrone systemer-kurset indeholder 4 lektioner i alt.

Mød arbejdskøer

Velkommen til arbejdskøer! I distribuerede systemer har du ofte opgaver, der tager tid at fuldføre, f.eks. behandling af et billede eller generering af en rapport.

Arbejdskøer er et mønster, der hjælper med effektivt at fordele disse tidskrævende opgaver mellem flere arbejdere (forbrugere), så ingen enkelt arbejder bliver overbelastet.

Hvorfor bruge arbejdskøer?

Forestil dig, at du har mange opgaver, men kun én medarbejder. Hvis alle opgaver går til den ene medarbejder, bliver vedkommende overvældet, og opgaverne hober sig op.

Belastningsfordeling: Med arbejdskøer kan du tilføje flere arbejdere, der deler belastningen.
Asynkron behandling: Producenten venter ikke på, at en opgave bliver færdig, men føjer den blot til køen.
Pålidelighed: Hvis en arbejder fejler, kan andre tage opgaverne.

Sådan fungerer arbejdskøer

Opsætningen af en arbejdskø er enkel:

Én producent sender meddelelser (opgaver) til en enkelt kø.
Flere forbrugere lytter til den samme kø.
RabbitMQ sikrer, at hver meddelelse leveres til kun én af de ventende forbrugere.

På den måde bliver opgaver aldrig duplikeret, og de behandles parallelt.

Fair fordeling: Round-robin

Som standard fordeler RabbitMQ meddelelser til forbrugere ved hjælp af en round-robin-strategi. Det betyder, at meddelelser sendes til forbrugerne på skift:

Forbruger 1 får den første meddelelse.
Forbruger 2 får den anden meddelelse.
Forbruger 1 får den tredje meddelelse og så videre.

Målet er en jævn fordeling af opgaverne mellem alle aktive forbrugere.

Opgaveproducenten

Lad os oprette en producent, der sender 10 opgaver til vores kø. Hver opgave bliver en enkel streng som 'Processing image 1'.

Kør denne kode én gang for at fylde køen med opgaver.

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()) {

            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            for (int i = 0; i < 10; i++) {
                String message = "Processing image " + (i + 1);
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
                System.out.println(" [x] Sent '" + message + "'");
            }
            System.out.println(" [x] All tasks sent.");
        }
    }
}

Gennemgang af producentkoden

Hvad sker der i vores producer-kode?

Vi opretter en forbindelse og en kanal, så vi kan kommunikere med RabbitMQ.
channel.queueDeclare(QUEUE_NAME, false, false, false, null); sikrer, at køen findes. Flagene false gør den ikke-persistent og ikke-eksklusiv for nemheds skyld her.
En løkke sender 10 meddelelser til task_queue. Hver meddelelse repræsenterer en separat opgave.

Vores første opgaveforbruger

Lad os nu oprette en forbruger, som vi kalder en "worker". Denne worker lytter efter opgaver fra task_queue.

Vi simulerer en langvarig opgave ved hjælp af Thread.sleep(). Kør denne kode i et terminalvindue.

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"); // Assuming RabbitMQ is local

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

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            try {
                // Simulate long-running task
                Thread.sleep(1000); // 1 second per task
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                System.out.println(" [x] Done with '" + message + "'");
            }
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {});
    }
}

Gennemgang af forbrugerkoden

Lad os se på forbrugerens logik:

Ligesom producenten opretter den forbindelse og erklærer køen.
En DeliverCallback definerer handlingerne, når en meddelelse ankommer.
Inde i callback-funktionen simulerer Thread.sleep(1000) en opgave på 1 sekund.
channel.basicConsume(QUEUE_NAME, true, deliverCallback, ...) starter forbruget. true betyder, at meddelelser automatisk kvitteres efter levering.

Skalering med flere workers

Her er den centrale demonstration af arbejds køer:

1. Kør TaskConsumer-koden i to separate terminalvinduer (eller instanser).

2. Kør derefter TaskProducer-koden én gang.

Du vil se, at de 10 opgaver fordeles mellem dine to worker-instanser, som hver behandler omkring 5 opgaver på grund af RabbitMQ's round-robin-fordeling.

Quiz om arbejdskøer

Forestil dig, at du har en enkelt RabbitMQ-kø og to forbrugere (Worker A og Worker B), der lytter til den. En producent sender 4 meddelelser (M1, M2, M3, M4) til denne kø.

Hvilken påstand beskriver korrekt, hvordan meddelelserne typisk fordeles ved hjælp af RabbitMQ's standard-fair-dispatch?

Besvar den i den interaktive lektion

Arbejdskøer: Vigtigste pointer

Du har implementeret arbejdskøer, et grundlæggende mønster til fordeling af opgaver på flere forbrugere!

Arbejdskøer muliggør asynkron behandling og forhindrer enkelte fejlpunkter.
RabbitMQ's standardstrategi med round-robin sikrer, at opgaverne fordeles fair.
Ved at køre flere forbrugerinstanser kan du nemt skalere din kapacitet til opgavebehandling.

Nu dykker vi ned i, hvordan du gør din meddelelseshåndtering endnu mere robust med kvitteringer og meddelelsespersistens!

Gratis at komme i gang

Lær RabbitMQ: meddelelser og asynkrone systemer med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 11
Lektioner: 44

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Arbejdskøer: Fair fordeling” gratis?

Ja — alle 3 lektioner i læringssporet RabbitMQ: meddelelser og asynkrone systemer, inklusive “Arbejdskøer: Fair fordeling”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. RabbitMQ: meddelelser og asynkrone systemer-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Arbejdskøer: Fair fordeling”?

Implementér arbejdskøer for at fordele opgaver mellem flere forbrugere ved hjælp af en round-robin-fordelingsstrategi. Lær at behandle tidskrævende opgaver asynkront. Du øver dig i RabbitMQ: meddelelser og asynkrone systemer med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på RabbitMQ: meddelelser og asynkrone systemer?

Der kræves ingen tidligere erfaring. RabbitMQ: meddelelser og asynkrone systemer på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Arbejdskøer: Fair fordeling”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne RabbitMQ: meddelelser og asynkrone systemer-lektion?

Ja. Alle RabbitMQ: meddelelser og asynkrone systemer-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Hello World: Simpel kø
Arbejdskøer: Fair fordeling
Bekræftelser og holdbarhed for meddelelser
Publish/subscribe med fanout-exchanges

← Tilbage til RabbitMQ: meddelelser og asynkrone systemer