RabbitMQ-meldinger og asynkrone systemer · leksjon

Arbeidskøer: Rettferdig fordeling

Implementer arbeidskøer for å fordele oppgaver mellom flere konsumenter ved hjelp av en round-robin-strategi. Lær hvordan tidkrevende oppgaver kan behandles asynkront.

Leksjon 2 av 411 trinn

Arbeidskøer: Rettferdig fordeling er en gratis leksjon i RabbitMQ-meldinger og asynkrone systemer på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i RabbitMQ-meldinger og asynkrone systemer, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i RabbitMQ-meldinger og asynkrone systemer inneholder totalt 4 leksjoner.

Møt arbeidskøer

Velkommen til arbeidskøer! I distribuerte systemer har du ofte oppgaver som tar tid å fullføre, for eksempel å behandle et bilde eller generere en rapport.

Arbeidskøer er et mønster som effektivt fordeler slike tidkrevende oppgaver mellom flere arbeidere (konsumenter), slik at ingen enkeltarbeider blir overbelastet.

Hvorfor bruke arbeidskøer?

Se for deg at du har mange jobber som skal gjøres, men bare én ansatt. Hvis alle jobbene går til denne ene ansatte, blir vedkommende overveldet, og oppgavene hoper seg opp.

Lastbalansering: Arbeidskøer lar deg legge til flere arbeidere for å dele belastningen.
Asynkron behandling: Produsenten venter ikke på at en oppgave skal bli ferdig, men legger den bare i køen.
Pålitelighet: Hvis én arbeider svikter, kan andre ta over oppgavene.

Slik fungerer arbeidskøer

Oppsettet for en arbeidskø er enkelt:

Én produsent sender meldinger (oppgaver) til én kø.
Flere konsumenter lytter til den samme køen.
RabbitMQ sørger for at hver melding leveres til bare én av konsumentene som venter.

På denne måten blir oppgaver aldri duplisert, og de behandles parallelt.

Rettferdig fordeling: Round-robin

Som standard fordeler RabbitMQ meldinger til konsumenter ved hjelp av strategien round-robin. Det betyr at meldinger sendes til konsumentene etter tur:

Konsument 1 får den første meldingen.
Konsument 2 får den andre meldingen.
Konsument 1 får den tredje meldingen, og så videre.

Målet er å fordele oppgavene jevnt mellom alle aktive konsumenter.

Oppgaveprodusenten

La oss lage en produsent som sender 10 oppgaver til køen vår. Hver oppgave blir en enkel streng, for eksempel «Processing image 1».

Kjør denne koden én gang for å fylle køen med oppgaver.

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.");
        }
    }
}

Gjennomgang av produsentkoden

Hva skjer i produsentkoden vår?

Vi oppretter en tilkobling og en kanal for å kommunisere med RabbitMQ.
channel.queueDeclare(QUEUE_NAME, false, false, false, null); sørger for at køen finnes. false-flaggene gjør den ikke-persistent og ikke-eksklusiv for enkelhets skyld her.
En løkke sender 10 meldinger til task_queue. Hver melding representerer en egen oppgave.

Vår første oppgavekonsument

La oss nå opprette en konsument, som vi kaller en «worker». Denne workeren lytter etter oppgaver fra task_queue.

Vi simulerer en langvarig oppgave ved hjelp av Thread.sleep(). Kjør denne koden i et terminalvindu.

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 -> {});
    }
}

Gjennomgang av konsumentkoden

La oss se på logikken i konsumenten:

Akkurat som produsenten kobler den seg til og deklarerer køen.
En DeliverCallback definerer handlingene som utføres når en melding kommer inn.
Inne i callbacken simulerer Thread.sleep(1000) en oppgave på 1 sekund.
channel.basicConsume(QUEUE_NAME, true, deliverCallback, ...) starter konsumeringen. true betyr at meldinger bekreftes automatisk etter levering.

Skaler med flere workere

Her er hoveddemonstrasjonen av arbeidskøer:

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

2. Kjør deretter TaskProducer-koden én gang.

Du vil se at de 10 oppgavene fordeles mellom de to worker-instansene, slik at hver behandler omtrent 5 oppgaver på grunn av RabbitMQs round-robin-distribusjon.

Quiz om arbeidskøer

Tenk deg at du har én RabbitMQ-kø og to konsumenter (Worker A og Worker B) som lytter på den. En produsent sender 4 meldinger (M1, M2, M3, M4) til denne køen.

Hvilket utsagn beskriver mest nøyaktig hvordan meldingene vanligvis fordeles med RabbitMQs standard fordeling etter tur?

Besvar den i den interaktive leksjonen

Arbeidskøer: Viktige poeng

Du har implementert arbeidskøer, et grunnleggende mønster for å fordele oppgaver mellom flere konsumenter!

Arbeidskøer muliggjør asynkron behandling og hindrer enkeltstående feilkilder.
RabbitMQs standardstrategi med round-robin sørger for en rettferdig fordeling av oppgavene.
Ved å kjøre flere konsumentinstanser kan du enkelt skalere kapasiteten for oppgavebehandling.

Deretter skal vi se nærmere på hvordan du kan gjøre meldingshåndteringen enda mer robust med bekreftelser og meldingspersistens!

Gratis å komme i gang

Lær deg RabbitMQ-meldinger og asynkrone systemer med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 11
Leksjoner: 44

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Arbeidskøer: Rettferdig fordeling» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien RabbitMQ-meldinger og asynkrone systemer, inkludert «Arbeidskøer: Rettferdig fordeling», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i RabbitMQ-meldinger og asynkrone systemer inneholder totalt 4 leksjoner.

Hva lærer jeg i «Arbeidskøer: Rettferdig fordeling»?

Implementer arbeidskøer for å fordele oppgaver mellom flere konsumenter ved hjelp av en round-robin-strategi. Lær hvordan tidkrevende oppgaver kan behandles asynkront. Du øver på RabbitMQ-meldinger og asynkrone systemer med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med RabbitMQ-meldinger og asynkrone systemer?

Ingen tidligere erfaring er nødvendig. RabbitMQ-meldinger og asynkrone systemer på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Arbeidskøer: Rettferdig fordeling»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne RabbitMQ-meldinger og asynkrone systemer-leksjonen?

Ja. Alle RabbitMQ-meldinger og asynkrone systemer-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Hello World: Enkel kø
Arbeidskøer: Rettferdig fordeling
Meldingsbekreftelser og varighet
Publisering/abonnement med fanout-exchanges

← Tilbake til RabbitMQ-meldinger og asynkrone systemer