Wenn wir im herkömmlichen synchronen Entwicklungsmodell eine Funktion aufrufen, werden die Daten über die Parameter der Funktion übergeben und das endgültige Berechnungsergebnis wird über den Rückgabewert der Funktion zurückgegeben. Im asynchronen Multithread-Entwicklungsmodus unterscheiden sich die Übertragung und Rückgabe von Daten jedoch stark vom synchronen Entwicklungsmodus. Da das Ausführen und Beenden von Threads beim Übertragen und Zurückgeben von Daten unvorhersehbar ist, können Daten nicht wie Funktionen über Funktionsparameter und Rückgabeanweisungen zurückgegeben werden. In diesem Artikel werden aus den oben genannten Gründen verschiedene Methoden zum Übergeben von Daten an Threads vorgestellt. Im nächsten Artikel stellen wir Methoden zum Zurückgeben von Daten aus Threads vor.
Wenn du es zuerst nehmen willst, musst du es zuerst geben. Im Allgemeinen sind bei der Verwendung von Threads einige Initialisierungsdaten erforderlich, und der Thread verwendet diese Daten dann, um die Ergebnisse zu verarbeiten und zurückzugeben. Das erste, was in diesem Prozess zu tun ist, besteht darin, Daten an den Thread zu übergeben.
1. Übergeben Sie Daten über die Konstruktormethode <BR>Beim Erstellen eines Threads müssen Sie eine Instanz der Thread-Klasse oder ihrer Unterklasse erstellen. Daher ist es für uns nicht schwierig, darüber nachzudenken, Daten über die Konstruktormethode der Thread-Klasse an den Thread zu übergeben, bevor wir die Startmethode aufrufen. Und speichern Sie die eingehenden Daten mithilfe von Klassenvariablen zur Verwendung durch den Thread (wird tatsächlich in der Ausführungsmethode verwendet). Der folgende Code zeigt, wie Daten durch den Konstruktor übergeben werden:
Kopieren Sie den Codecode wie folgt:
Paket mythread;
Die öffentliche Klasse MyThread1 erweitert Thread
{
privater String-Name;
public MyThread1(String-Name)
{
this.name = Name;
}
public void run()
{
System.out.println("hello " + name);
}
public static void main(String[] args)
{
Thread thread = new MyThread1("world");
thread.start();
}
}
Da diese Methode beim Erstellen des Thread-Objekts Daten überträgt, sind die Daten bereits vorhanden, bevor der Thread ausgeführt wird, sodass die Daten nach der Ausführung des Threads nicht weitergegeben werden. Wenn Sie komplexere Daten übergeben möchten, können Sie Datenstrukturen wie Sammlungen und Klassen verwenden. Obwohl es sicherer ist, die Konstruktormethode zum Übertragen von Daten zu verwenden, führt dies zu großen Unannehmlichkeiten, wenn viele Daten übertragen werden müssen. Da Java keine Standardparameter hat, müssen Sie Überladung verwenden, wenn Sie ähnliche Effekte erzielen möchten. Dies macht nicht nur den Konstruktor selbst zu komplex, sondern erhöht auch die Anzahl der Konstruktoren erheblich. Um diese Situation zu vermeiden, übergeben Sie Daten daher über Klassenmethoden oder Klassenvariablen.
2. Daten über Variablen und Methoden übergeben <BR>Es gibt im Allgemeinen zwei Möglichkeiten, Daten an ein Objekt zu übergeben. Die erste Möglichkeit besteht darin, die Daten beim Erstellen des Objekts über die Konstruktormethode zu übergeben, und die andere Möglichkeit besteht darin, eine Reihe zu definieren von Daten in der Klasse. Weisen Sie dann nach dem Erstellen des Objekts Werte nacheinander über Objektinstanzen zu. Der folgende Code ist eine Modifikation der MyThread1-Klasse, die eine setName-Methode verwendet, um die Namensvariable festzulegen:
Kopieren Sie den Codecode wie folgt:
Paket mythread;
Die öffentliche Klasse MyThread2 implementiert Runnable
{
privater String-Name;
public void setName(String name)
{
this.name = Name;
}
public void run()
{
System.out.println("hello " + name);
}
public static void main(String[] args)
{
MyThread2 myThread = new MyThread2();
myThread.setName("world");
Thread thread = neuer Thread(myThread);
thread.start();
}
}
3. Übergeben Sie Daten über Rückruffunktionen <BR>Die beiden oben beschriebenen Methoden zum Übergeben von Daten an Threads werden am häufigsten verwendet. Beide Methoden übergeben jedoch aktiv Daten an die Thread-Klasse in der Hauptmethode. Bei Threads werden diese Daten passiv empfangen. In einigen Anwendungen ist es jedoch erforderlich, Daten dynamisch abzurufen, während der Thread ausgeführt wird. Beispielsweise werden in der Ausführungsmethode des folgenden Codes drei Zufallszahlen generiert und anschließend die Summe dieser drei Zufallszahlen über die Prozessmethode berechnet der Work-Klasse und gibt das Ergebnis über den Wert der Data-Klasse zurück. Wie aus diesem Beispiel ersichtlich ist, müssen drei Zufallszahlen ermittelt werden, bevor ein Wert zurückgegeben wird. Mit anderen Worten, dieser Wert kann nicht im Voraus an die Thread-Klasse übergeben werden.
Kopieren Sie den Codecode wie folgt:
Paket mythread;
Klassendaten
{
öffentlicher int-Wert = 0;
}
Klassenarbeit
{
öffentlicher Void-Prozess (Datendaten, Ganzzahlen)
{
for (int n : Zahlen)
{
data.value += n;
}
}
}
Die öffentliche Klasse MyThread3 erweitert Thread
{
private Arbeitsarbeit;
public MyThread3(Arbeit Arbeit)
{
this.work = Arbeit;
}
public void run()
{
java.util.Random random = new java.util.Random();
Daten data = new Data();
int n1 = random.nextInt(1000);
int n2 = random.nextInt(2000);
int n3 = random.nextInt(3000);
work.process(data, n1, n2, n3); // Callback-Funktion verwenden
System.out.println(String.valueOf(n1) + „+“ + String.valueOf(n2) + „+“
+ String.valueOf(n3) + "=" + data.value);
}
public static void main(String[] args)
{
Thread thread = new MyThread3(new Work());
thread.start();
}
}
Die Prozessmethode im obigen Code wird als Rückruffunktion bezeichnet. Rückruffunktionen sind im Wesentlichen Ereignisfunktionen. In der Windows-API werden Rückruffunktionen häufig verwendet, um mit Daten zwischen dem Programm, das die API aufruft, zu interagieren. Daher ist der Aufruf der Rückruffunktion der ursprüngliche Prozess zum Auslösen des Ereignisses. In diesem Beispiel entspricht der Aufruf der Prozessmethode zum Abrufen von Daten dem Auslösen eines Ereignisses in der Ausführungsmethode.
