Thread-per-Message-Modus (diese Arbeit bleibt Ihnen überlassen)
Wenn Sie sehr beschäftigt sind, gibt es unten einen Kurier im Unternehmen, sodass Sie Ihren Kollegen anvertrauen, dass Sie Ihren Kurier erhalten, damit Sie weiterhin Ihren Job machen können
Im Thread-per-Message-Modus sind das Delegierende der Nachricht und das Ausführungsende unterschiedliche Threads. Das Delegierte Ende der Nachricht zeigt den Thread für Ausführungsende an, und diese Arbeit wird Ihnen übergeben.
Hostklasse:
Die Klasse, die einen Thread für Anfragen erstellt, erstellt hauptsächlich, indem ein neuer Thread geöffnet wird, den Helfergriff aufgerufen und den zu druckenden Text übergeben.
public class Host {private endgültige Helper Helper = new Helper (); public void request (endgültig int count, endgültig ch) {System.out.println ("Anfrage start"); neuer Thread () {public void run () {HELPER.handle (count, c);}}. start ();Helferklasse:
Bietet eine Zeichenanzeigefunktion, und die langsame Methode simuliert die Druckzeit
public class helfer {public void Handle (int count, char c) {System.out.println ("Handlungsmethode start"); für (int i = 0; i <count; i ++) {langsam (); System.out.Out.print (c);} System.out.Out.println (""); {Thread.sleep (100);} catch (InterruptedException e) {// Todo automatisch generiert blocke.printstacktrace ();}}}Hauptklasse:
Erstellen Sie eine Instanz des Hosts und rufen Sie die Anforderungsmethode an
public static void main (String [] args) {System.out.println ("Hauptstart"); Host Host = new Host ();Testergebnisse:
Hauptanfang
Die Anforderungsmethode hat begonnen
Das Ende der Anforderungsmethode
Die Anforderungsmethode hat begonnen
Das Ende der Anforderungsmethode
Die Anforderungsmethode hat begonnen
Das Ende der Anforderungsmethode
Hauptende
Starten Sie die Handlungsmethode
Starten Sie die Handlungsmethode
Starten Sie die Handlungsmethode
Bacbacbacbacbacbacbacbacba
Ende der Handlungsmethode
CBCBCBCBCBCBCBCBCBCBCBCBCBCBCB
Ende der Handlungsmethode
CCCCCCCCCCCC
Ende der Handlungsmethode
Aus den Ergebnissen des Vorgangs können wir feststellen, dass die Anforderungsmethode nicht darauf wartet, dass die Handlungsmethode vor der Ausführung ausgeführt wird, sondern die Handlungsmethode aufruft und zur Anforderungsmethode zurückgegeben wird, bis der Lauf endet. Daher entspricht es der Anforderungsmethode, die die Arbeit zum Drucken einer bestimmten Anzahl von Zeichen, die an die Handelsmethode ausgeführt werden sollen, übergeben, und die Anforderungsmethode kann andere Anweisungen in der dummen Methode ausführen, ohne auf die Vervollständigung der Handlungsmethode zu warten. Dies zeigt uns auch, dass in diesem Modus, wenn einige Arbeiten zeitaufwändig sind, neue Threads gestartet werden können, um die Verarbeitung durchzuführen. Dieser Modus kann auf den Server angewendet werden, wodurch die Reaktionszeit des Servers verkürzt werden kann.
Erklären Sie den Prozess und den Thread:
Der größte Unterschied zwischen Threads und Prozessen ist, ob Speicher koexistiert.
Jeder Prozess hat seinen eigenen unabhängigen Speicherraum. Ein Prozess kann die Erinnerung anderer Prozesse ohne Autorisierung nicht lesen und schreiben. Da der Speicherraum der Prozesse unabhängig voneinander ist, muss sich ein Prozess nicht darum kümmern, durch andere Prozesse zerstört zu werden.
Themen können koexistieren. Ein Thread schreibt Inhalte in die Instanz, und andere Threads können den Inhalt der Instanz lesen. Da mehrere Threads auf dieselbe Instanz zugreifen können, müssen wir sicherstellen, dass es mutex korrekt ausgeführt wird.
Optimierung des Hostdesigns:
1. Entwerfen Sie die Hostklasse mit der ThreadFactory -Schnittstelle unter dem Paket java.util.Concurrent
public class Host {public void request (endgültige int count, endgültig ch) {system.out.println ("Anforderungsmethode"); endet ");}}Entsprechender Host -Instanziierungsobjekt:
Host Host = New Host (Executors.DefaultThreadFactory ());
Der Vorteil dieses Designs besteht darin, dass der ursprüngliche Instanzcode, der mit neuem erstellt wurde, von der Klasse von Java.lang.Thread abhängt und den Teil des Erstellungs -Threads nicht steuern kann und weniger wiederverwendbar ist. Wenn ThreadFactory verwendet wird, um die Objekte der entsprechenden Klasse zu speichern und die NewThrad -Methode aufzurufen, um einen neuen Thread zu erstellen, wird die Erstellung des Threads realisiert. Dies hängt nicht mehr von der Thread -Klasse ab, sondern hängt von dem im Konstruktor übergebenen ThreadFactory -Objekt ab, der die Details zur Steuerung der Erstellung von Threads implementiert.
Gestalten Sie die Hostklasse mit der Schnittstelle java.util.concurrent.executor: neu:
Die vorherige ThreadFactory -Schnittstelle verbirgt die Details der Thread -Erstellung, verbergt jedoch nicht die Thread -Erstellungsvorgänge. Wenn die Ausführungsschnittstelle verwendet wird, werden auch die Thread -Erstellungsvorgänge versteckt.
public class Host {private endgültige helfer = new Helper (); privater Final Executor Executor; Public Host (Executor Executor) {this.executor = Executor;} public void request (endgültige Int Count, Final char c) {System.out.println ("Anfrage-Methode begonnen"); Methode stubHelper.handle (count, c);}});Erstellt mit java.util.concurrent
öffentliche Klasse Host {Private Final Helper Helper = new Helper (); Private Final ScheduleDexecutorService ScheduledexecutorService; öffentlicher Host (pleduledexecutorService enderExecutorService) {this. gestartet "); plantedexecutorService.Schedule (new Runnable () {@Overridepublic void run () {// Todo automatisch generierte Methode Stubhelper.handle (count, c);}}, 3l, Timeunit.seconds);Testen Sie den Eintrag der Hauptfunktion:
EnderEdexecutorService enderExecutorService = Executors.NewScheduledThreadpool (5); Host Host = neuer Host (enderEdexecutorService); Versuchen Sie {Host.Request (10, 'a'); blocke.printstacktrace ();} endlich {plantedexecutorService.shutdown (); System.out.println ("Main End");};};};Zusammenfassen
Die Clientrolle ruft die Anforderungsmethode der Host -Rolle auf, und die tatsächliche Verarbeitung der Anfrage wird für die Ausführung an den Helfergriff übergeben. Wenn der Client jedoch die Handlungsmethode direkt aus der Anforderung aufruft, kann er erst dann aus der Handlungsmethode zurückgegeben werden, wenn der tatsächliche Vorgang vorbei ist. Dies verringert die Antwortleistung der Anfrage. Daher startet die Host -Rolle einen neuen Thread, der zur Verarbeitung der Anforderung aus der Client -Rolle verwendet und den Thread den Handle aufruft, damit der Thread die Anforderung sofort aus dem Handle zurückgeben kann. Dies ist der Thread-per-Message-Modus.