Arbeiterfadenmuster

Arbeiter bedeutet "Arbeiter". Im WorkerThread-Muster arbeiten ** Arbeitsthreads ** nacheinander und verarbeiten sie. Wenn kein Job vorhanden ist, wartet der Worker-Thread auf einen neuen Job. Worker Thread wird manchmal als ** Hintergrund-Thread ** bezeichnet.

Betrachten Sie das folgende Beispiel. Ein Thread in der ClientThread-Klasse sendet eine Jobanforderung an die Channel-Klasse. Eine Instanz der Channel-Klasse verfügt über fünf Worker-Threads. Der Worker-Thread wartet auf eine Jobanforderung. Wenn eine Jobanforderung eintrifft, empfängt der Arbeitsthread eine Jobanforderung von Channel und verarbeitet sie. Wenn der Vorgang abgeschlossen ist, kehrt der Worker-Thread zu Channel zurück und wartet auf die nächste Anforderung.

(Den gesamten Code finden Sie in diesem Handbuch.)

`Main.java`


public class Main { 
    public static void main(String[] args) { 
        Channel channel = new Channel(5);   //Erstellen Sie 5 Arbeitsthreads
        channel.startWorkers(); //Starten Sie einen Worker-Thread
        new ClientThread("Alice", channel).start();  //Starten Sie einen Thread, um eine Jobanfrage zu stellen
        new ClientThread("Bobby", channel).start(); 
        new ClientThread("Chris", channel).start(); 
    } 
}

`ClientThread.java`


public class ClientThread extends Thread { 
    ...
    public void run() { 
        try { 
            for (int i = 0; true; i++) { 
                Request request = new Request(getName(), i); 
                channel.putRequest(request);  //Stellen Sie eine Jobanfrage
                Thread.sleep(random.nextInt(1000)); 
            } 
        } catch (InterruptedException e) { 
        } 
    } 
}

`Channel.java`


public class Channel { 
    private static final int MAX_REQUEST = 100; 
    private final Request[] requestQueue; 
    private int tail;
    private int head;
    private int count;
 
    private final WorkerThread[] threadPool; 
 
    public Channel(int threads) { 
        this.requestQueue = new Request[MAX_REQUEST]; 
        this.head = 0; 
        this.tail = 0; 
        this.count = 0; 
 
        threadPool = new WorkerThread[threads]; 
        for (int i = 0; i < threadPool.length; i++) { 
            threadPool[i] = new WorkerThread("Worker-" + i, this); 
        } 
    }

    public void startWorkers() { 
        for (int i = 0; i < threadPool.length; i++) { 
            threadPool[i].start(); 
        } 
    }

    public synchronized void putRequest(Request request) { 
        while (count >= requestQueue.length) { 
            try { 
                wait(); 
            } catch (InterruptedException e) { 
            } 
        } 
        requestQueue[tail] = request; 
        tail = (tail + 1) % requestQueue.length; 
        count++; 
        notifyAll(); 
    }

    public synchronized Request takeRequest() { 
        while (count <= 0) { 
            try { 
                wait(); 
            } catch (InterruptedException e) { 
            } 
        } 
        Request request = requestQueue[head]; 
        head = (head + 1) % requestQueue.length; 
        count--; 
        notifyAll(); 
        return request; 
    } 
}

`WorkerThread.java`


public class WorkerThread extends Thread { 
    ...
    public void run() { 
        while (true) { 
            Request request = channel.takeRequest(); //Geh und hol dir einen Job
            request.execute(); 
        } 
    } 
}

Die Channel-Klasse verfügt über ein Feld namens requestQueue zum Übergeben von Arbeitsanforderungen. Die putRequest-Methode stellt eine Anforderung in diese Warteschlange und die takeRequest-Methode ruft sie ab. Hier wird das Producer-Consumer-Muster verwendet. Das Thread-Per-Message-Muster hat bei jeder Ausführung eines Jobs einen neuen Thread erzeugt. Im Worker-Thread-Muster führen ** Worker-Threads die Arbeit jedoch wiederholt aus, sodass kein neuer Thread gestartet werden muss. ** WorkerThread verfügt nur über eine Channel-Instanz, um eine Jobanfrage zu erhalten, und weiß nichts über den jeweiligen Job.

Charakter

Kundenrolle Die Client-Rolle erstellt eine Jobanforderung als Anforderungsrolle und übergibt sie an die Channel-Rolle. Im Beispielprogramm spielte die ClientThread-Klasse diese Rolle.

Kanalrolle Die Channel-Rolle empfängt die Request-Rolle von der Client-Rolle und übergibt sie an die Worker-Rolle. Im Beispielprogramm spielte die Channel-Klasse diese Rolle.

Arbeiterrolle Die Worker-Rolle empfängt die Request-Rolle von der Channel-Rolle und führt die Arbeit aus. Holen Sie sich nach der Arbeit die nächste Anforderungsrolle. Im Beispielprogramm spielte die WorkerThread-Klasse diese Rolle.

Rolle anfordern Die Anforderungsrolle besteht darin, einen Job darzustellen. Die Anforderungsrolle enthält die zur Ausführung der Aufgabe erforderlichen Informationen. Im Beispielprogramm spielte die Request-Klasse diese Rolle.

Tipps zur Erweiterung Ihrer Gedanken

Erhöhter Durchsatz Im Gegensatz zum Thread-Per-Message-Muster hat das Worker-Thread-Muster eines der Themen ** Wiederverwendung von Threads und Recycling zur Steigerung des Durchsatzes **.

Kapazitätskontrolle Die Anzahl der Dienste, die gleichzeitig bereitgestellt werden können, wird als Kapazität bezeichnet. Die Anzahl der Arbeiterrollen kann frei bestimmt werden. Im Beispielprogramm sind dies die Argumentthreads, die dem Channel-Konstruktor übergeben werden. Je mehr Worker-Rollen Sie haben, desto mehr Arbeit können Sie parallel ausführen. Die Vorbereitung von mehr Worker-Rollen als die Anzahl der gleichzeitig angeforderten Jobs ist jedoch nutzlos und verbraucht mehr Ressourcen. Die Anzahl der Worker-Rollen muss nicht unbedingt beim Start festgelegt werden und kann dynamisch geändert werden. Die Channel-Rolle enthält die Request-Rolle. Wenn die Anzahl der Anforderungsrollen, die von der Channel-Rolle gehalten werden können, groß ist, kann der Unterschied in der Verarbeitungsgeschwindigkeit zwischen der Client-Rolle und der Worker-Rolle gefüllt (gepuffert) werden. Es wird jedoch viel Speicher benötigt, um die Anforderungsrolle zu halten. Sie können sehen, dass es hier einen ** Kompromiss zwischen Kapazität und Ressource ** gibt.

Trennung von Aufruf und Ausführung Bei einem normalen Methodenaufruf werden "Methodenaufruf" und "Methodenausführung" nacheinander ausgeführt. ** Bei einem normalen Methodenaufruf sind Aufruf und Ausführung untrennbar miteinander verbunden **. ** Worker-Thread-Muster und Thread-Per-Message-Muster trennen jedoch Methodenaufruf und -ausführung **. Der Aufruf einer Methode wird als Aufruf bezeichnet, und die Ausführung wird als Ausführung bezeichnet. ** Das Worker-Thread-Muster und das Thread-Per-Message-Muster trennen den Aufruf und die Ausführung einer Methode **. Dies hat die folgenden Vorzüge.

Verbesserte Reaktionsfähigkeit Selbst wenn die Ausführung einige Zeit in Anspruch nimmt, können diejenigen, die einen Aufruf haben, fortfahren.
Kontrolle der Ausführungsreihenfolge (Scheduling) Sie können die Anforderungsrolle priorisieren und die Reihenfolge steuern, in der die Channgel-Rolle die Anforderungsrolle an die Worker-Rolle übergibt. Dies wird als Anforderung ** Zeitplanung ** bezeichnet.
Stornierbar / Wiederholbar Obwohl der Aufruf durchgeführt wurde, kann die Ausführung eine Funktion namens Abbruch realisieren.

--Verteilte Verarbeitung Es wird einfacher, den aufzurufenden Computer und den auszuführenden Computer zu trennen.

Vielseitige Anforderungsrolle Wenn Sie beispielsweise eine Unterklasse der Request-Klasse erstellen und ihre Instanz an Channel übergeben, ruft WorkerThread die Ausführung für diese Instanz problemlos auf. Dies kann als Verwendung von ** Polymorphismus ** ausgedrückt werden. Da alle zur Ausführung der Arbeit erforderlichen Informationen in der Anforderungsrolle beschrieben sind, müssen die Channel-Rolle und die Worker-Rolle diese nicht ändern, auch wenn eine facettenreiche Anforderungsrolle erstellt und die Arbeitstypen erhöht werden. Selbst wenn die Anzahl der Arbeitstypen zunimmt, ruft die Worker-Rolle nur die Ausführungsmethode der Anforderungsrolle auf.

Zusammenfassung von "In Java gelernten Entwurfsmustern (Multithread Edition)" (Teil 10)

Arbeiterfadenmuster

Main.java

ClientThread.java

Channel.java