1. Was ist ein Thread?
Thread: Ein einzelner Ablaufsteuerungsprozess in einem Programm. Eine relativ unabhängige und planbare Ausführungseinheit innerhalb des Prozesses ist die Grundeinheit für das System, um die CPU unabhängig zu planen und zu verteilen.
Multithreading: Das gleichzeitige Ausführen mehrerer Threads zur Erledigung verschiedener Aufgaben in einem einzigen Programm wird als Multithreading bezeichnet.
Funktionen:
1) Leichter Prozess, die kleinste ausführbare Einheit im Programmablauf. Threads besitzen keine Systemressourcen und mehrere Threads teilen sich die Ressourcen, die dem Prozess gehören.
2) Ein Thread kann einen anderen Thread erstellen und mehrere Threads können gleichzeitig ausgeführt werden.
3) Wenn mehrere Threads während des Systembetriebs Ressourcen beanspruchen, kommt es zu einer Unterbrechung der parallelen Ausführung, aber tatsächlich gibt es eine Reihenfolge.
4) Ein Prozess enthält mindestens einen Thread, den Hauptthread.
2. Welchen Status haben Threads?
Threads haben fünf Zustände: neu, bereit, läuft, blockiert und beendet.
①Neu: Der Thread wird erstellt, ohne dass eine Methode ausgeführt wird, z. B. Thread th = new Thread().
② Bereit: Wenn die Startmethode des Threads aufgerufen wird, wird der Thread-Status ausgelöst, um in den Bereitschaftszustand zu wechseln und auf den Aufruf der CPU zu warten. Nur Threads im Bereitschaftszustand werden von der CPU geplant, und eine einzelne CPU führt sie nicht sofort aus.
③Run: Wenn die CPU einen Aufruf an diesen Thread initiiert, wechselt sie in den laufenden Zustand.
④Blockierung: Wenn ein Thread aus irgendeinem Grund nicht mehr das Recht hat, die CPU zu nutzen, wird er blockiert.
Das Blockieren hat die folgenden Situationen:
1) Schlaf (lange Mühlen): Der Parameter ist die Anzahl der Millisekunden, die den Thread dazu veranlassen, innerhalb der angegebenen Zeit in die Blockierung einzutreten bestanden, geht es in den Bereitschaftszustand über.
2) Suspend() und Resume(): Suspend führt dazu, dass der Thread hängt, und Resume muss ausgeführt werden, um den Thread fortzusetzen.
3) yield(): Ähnlich wie sleep(), aber der Benutzer kann nicht angeben, wie lange die Pause dauern soll. Es kann nur Threads mit derselben Priorität die Möglichkeit geben, ohne Blockierung einzugeben. Genau wie in einer Warteschlange tauscht die Person vorne den Platz mit der Person hinten, sie steht aber immer noch in der Warteschlange.
4) wait() und notify(): wait() versetzt den Thread in einen blockierenden Zustand. Es gibt zwei Formen, eine gibt die Anzahl der Millisekunden an und die andere hat keine Parameter. Ersteres kann über notify() aufgerufen oder nach einer bestimmten Zeit automatisch wiederhergestellt werden; letzteres muss über notify() aufgerufen werden.
5) Synchronblockierung: Warten auf Synchronisierungssperrressourcen. Wenn mehrere Threads um dieselbe Ressource konkurrieren, kann nur ein Thread die Sperre erhalten und andere Threads müssen warten.
⑤ Beendigung: Der Thread endet, nachdem die Thread-Ausführung abgeschlossen ist oder eine Ausnahme auftritt.
3. Wie erstelle ich einen Thread?
Es gibt drei Möglichkeiten, Java-Threads zu implementieren: die Thread-Klasse erben, die Runnable-Schnittstelle implementieren und Callable und FutureTask verwenden (kann Rückgabewerte haben)
1. Überschreiben Sie run() die Thread-Klassenmethode
class MyThread erweitert Thread {
@Override
public void run() {
for (int i = 0; i
System.out.println(Thread.currentThread().getName() " " i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
System.out.println(Thread.currentThread (). getName());
MyThread th1 = new MyThread();
MyThread th2 = new MyThread();
th1.start();
th2.start();
}
}
Ausgabe: main
Thread-1 0
Thread -0 0
Thread-1 1
Thread-1 2
...
Die vom Thread zu implementierende Logik ist in geschrieben Führen Sie die Methode aus, indem Sie die start()-Methode des Threads ausführen, um den Thread in den Bereitschaftszustand zu versetzen und darauf zu warten, dass die CPU Ressourcen zuweist.
Sie können sehen, dass zwei Threads parallel ausgeführt werden und die CPU zufällig abrufen.
2. Versucht, die Runnable-Schnittstelle und die run()-Methode zu implementieren
Klasse MyThread implementiert Runnable {
@Override
public void run() {
for (int i = 0; i
System.out.println(Thread.currentThread().getName() " " i );
}
}
}
public class ThreadDemo {
public static void main( String[] args) {
System.out.println(Thread.currentThread().getName());
MyThread th = new MyThread();
Thread t1 = neuer Thread(th);
Thread t2 = neuer Thread(th);
t1.start();
t2.start();
}
}
Ausgabe: main
Thread-0 0
Thread-0 1
Thread- 1 0
Thread-0 2
...
Instanziieren Sie Thread, indem Sie die MyThread-Instanz an den Thread-Konstruktor übergeben, die Startmethode von Thread aufrufen und den Thread starten .
ps: Was ist der Unterschied zwischen dem Erben von Thread und der Implementierung der Runnable-Schnittstelle?
1: Ersteres ist die Einzelvererbung, die Einschränkungen aufweist, aber mehrere Schnittstellen implementiert werden können.
2: Letzteres kann die gemeinsame Nutzung von Ressourcen realisieren.
Bei der Multithread-Programmierung wird dringend empfohlen, Runnable zu verwenden
3. Verwenden Sie Callable- und Future-Schnittstellen, um Threads zu erstellen.
Erstellen Sie insbesondere eine Implementierungsklasse der Callable-Schnittstelle und implementieren Sie die Methode clall().
Und verwenden Sie die FutureTask-Klasse, um das Objekt der Callable-Implementierungsklasse zu umschließen, und verwenden Sie dieses FutureTask-Objekt als Ziel des Thread-Objekts, um einen Thread zu erstellen.
Klasse MyCallable implementiert Callable {
@Override
public Integer call() löst Ausnahme {
return 1;
}
}
public class ThreadDemo {
public static void main(String[] args) {
Callable
myCallable = new MyCallable();//Instantiate MyCallable
FutureTask
ft = new FutureTask(myCallable);//Package FutureTask
Thread thread = new Thread(ft);//Übergeben Sie FutureTask an das Thread-Konstrukt und instanziieren Sie den Thread
thread.start();//Starten Sie den Thread
Integer result = ft.get();//Rückgabewert abrufen
System.out.println(result);
}
}
1) Implementieren Sie die call()-Methode in der Callable-Schnittstelle. Dies ist die Logik, die vom Thread ausgeführt werden soll.
2) Die get()-Methode von FutureTask blockiert, bis die call()-Methode ausgeführt wird und der Rückgabewert erhalten wird.
