Santa's Holiday Race: Die Magie des Java-Multithreadings

In einem fernen verschneiten Königreich, in dem Schneeverwehungen wie Diamanten leuchten und die Sterne Märchen flüstern, bereitete sich der Weihnachtsmann auf die magischste Nacht des Jahres vor. Seine Fabrik summte wie ein riesiges Musikinstrument: Elfen rannten mit Kisten umher, Spielzeug funkelte in bunten Farben und bei jedem neuen fertigen Geschenk läuteten Glocken.

Aber die Magie war in Gefahr.

„Zu viele Spielzeuge! Der Feed ist voll!“ — beschwerte sich der Chefproduzent der Elfen.
„Wir haben keine Zeit zum Packen!“ - wiederholte ihm der packende Elf.

Der Weihnachtsmann dachte: „Wie kann ich meinen Elfen helfen? Sie geben ihr Bestes, aber ohne Magie kommen sie nicht aus.“

Erste Magie: Synchronisation

Der Weihnachtsmann wandte sich einem Zauber zu, der als „synchronisiert“ bekannt ist. Dadurch wurde eine Schutzbarriere geschaffen, damit die Elfen bei der Arbeit mit dem gemeinsamen Klebeband nicht drängeln und verwirrt werden.

„Jetzt kann nur noch einer von euch gleichzeitig Spielzeug ablegen oder aufheben“, erklärte der Weihnachtsmann.

So sah es aus:

class SantaFactory {
    private final Queue<String> conveyorBelt = new LinkedList<>();
    private final int MAX_CAPACITY = 10;

    public void produce(String toy) throws InterruptedException {
        synchronized (conveyorBelt) {
            while (conveyorBelt.size() == MAX_CAPACITY) {
                System.out.println("Производитель ждёт: лента заполнена!");
                conveyorBelt.wait(); // Производитель ждёт, пока появится место
            }
            conveyorBelt.add(toy);
            System.out.println("Игрушка произведена: " + toy);
            conveyorBelt.notifyAll(); // Уведомляем упаковщиков о новой игрушке
        }
    }

    public void consume() throws InterruptedException {
        synchronized (conveyorBelt) {
            while (conveyorBelt.isEmpty()) {
                System.out.println("Потребитель ждёт: игрушек нет!");
                conveyorBelt.wait(); // Упаковщик ждёт, пока появится игрушка
            }
            String toy = conveyorBelt.poll();
            System.out.println("Игрушка упакована: " + toy);
            conveyorBelt.notifyAll(); // Уведомляем производителей о свободном месте
        }
    }
}

Magische Eigenschaften von „wait“ und „notifyAll“:

wait(): Versetzt den Thread in den Ruhezustand, bis eine Bedingung (z. B. leeres Band) falsch wird.
notifyAll(): Weckt alle wartenden Threads auf, um zu prüfen, ob sie fortfahren können.

Zweite Magie: BlockingQueue

Der Weihnachtsmann erkannte, dass die Elfen oft vergessen hatten, notifyAll anzurufen, was zu Verzögerungen führte. Dann benutzte er ein magisches Tool – BlockingQueue, das sich selbst um die Threads kümmerte.

BlockingQueue führt Folgendes aus:

Wenn das Band voll ist, wartet der Hersteller automatisch.
Wenn das Band leer ist, versteht der Packer selbst, dass er warten muss.

class SantaFactory {
    private final Queue<String> conveyorBelt = new LinkedList<>();
    private final int MAX_CAPACITY = 10;

    public void produce(String toy) throws InterruptedException {
        synchronized (conveyorBelt) {
            while (conveyorBelt.size() == MAX_CAPACITY) {
                System.out.println("Производитель ждёт: лента заполнена!");
                conveyorBelt.wait(); // Производитель ждёт, пока появится место
            }
            conveyorBelt.add(toy);
            System.out.println("Игрушка произведена: " + toy);
            conveyorBelt.notifyAll(); // Уведомляем упаковщиков о новой игрушке
        }
    }

    public void consume() throws InterruptedException {
        synchronized (conveyorBelt) {
            while (conveyorBelt.isEmpty()) {
                System.out.println("Потребитель ждёт: игрушек нет!");
                conveyorBelt.wait(); // Упаковщик ждёт, пока появится игрушка
            }
            String toy = conveyorBelt.poll();
            System.out.println("Игрушка упакована: " + toy);
            conveyorBelt.notifyAll(); // Уведомляем производителей о свободном месте
        }
    }
}

Dritte Magie: Executors und Thread-Pool

Damit die Elfen nicht müde werden, hat der Weihnachtsmann ein magisches Werkzeug geschaffen – einen Fadenpool. Nun erfüllte jeder Elf seine Aufgabe und ihre Anzahl wurde automatisch reguliert.

„Die Wichtel werden nicht mehr hintereinander herlaufen, alles läuft wie geschmiert“, freute sich der Weihnachtsmann.

Codebeispiel:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class SantaFactoryBlocking {
    private final BlockingQueue<String> conveyorBelt = new ArrayBlockingQueue<>(10);

    public void produce(String toy) throws InterruptedException {
        conveyorBelt.put(toy); // Если лента заполнена, поток автоматически ждёт
        System.out.println("Игрушка произведена: " + toy);
    }

    public void consume() throws InterruptedException {
        String toy = conveyorBelt.take(); // Если лента пуста, поток автоматически ждёт
        System.out.println("Игрушка упакована: " + toy);
    }
}

Magische Eigenschaften von Executors:

newFixedThreadPool(n): Erstellt einen Pool von n Threads, der wiederverwendet wird.
send(task): Startet eine Aufgabe in einem der Threads.
Shutdown(): Stoppt die Ausführung, nachdem alle Aufgaben abgeschlossen sind.

Vierte Magie: CompletableFuture

Im letzten Schritt fügte der Weihnachtsmann noch etwas mehr Magie hinzu: Jetzt arbeiteten die Elfen asynchron, was den Prozess beschleunigte.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SantaRaceWithExecutors {
    public static void main(String[] args) {
        SantaFactoryBlocking factory = new SantaFactoryBlocking();
        ExecutorService executor = Executors.newFixedThreadPool(4); // 4 эльфа

        // Запускаем 2 производителя
        for (int i = 1; i <= 2; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 1; j <= 20; j++) {
                        factory.produce("Игрушка #" + j);
                        Thread.sleep(100); // Производство занимает время
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // Запускаем 2 упаковщика
        for (int i = 1; i <= 2; i++) {
            executor.submit(() -> {
                try {
                    for (int j = 1; j <= 20; j++) {
                        factory.consume();
                        Thread.sleep(150); // Упаковка занимает время
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        executor.shutdown(); // Завершаем работу после выполнения всех задач
    }
}

Magische Eigenschaften von CompletableFuture:

Asynchron: Aufgaben werden in einem Hintergrundthread ausgeführt, ohne den Hauptthread zu blockieren.
Benutzerfreundlichkeit: Threads müssen nicht manuell verwaltet werden.

Das neue Jahr ist gerettet!

Als die letzten Spielsachen eingepackt waren, seufzte der Weihnachtsmann vor Freude. „Elfen, du hast einen unglaublichen Job gemacht. Die Magie des Multithreadings hat uns nicht nur schneller, sondern auch glücklicher gemacht!“

Und jetzt erzählt der Weihnachtsmann seinen Assistenten jeden Abend an Silvester ein Märchen darüber, wie Multithreading die Feiertage gerettet hat.

✨ Frohes neues Jahr, Freunde! ?

Das obige ist der detaillierte Inhalt vonSanta's Holiday Race: Die Magie des Java-Multithreadings. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!