1. Das Schreiben von Multithread-Programmen in Java ist viel einfacher als in anderen Programmiersprachen. Wird hauptsächlich über die Runnable-Schnittstelle und die Thread-Klasse implementiert.
publicclassSimpleRunnable implements Runnable{
private String message;
publicstaticvoid main(String[] args) {
SimpleRunnabler1 = new SimpleRunnable("Hello");
Threadt1 = new Thread(r1);
t1.start();
for(;;){
System.out.println("Bye-bye");
}
}
public SimpleRunnable(String message){
this.message = message;
}
@Override
publicvoid run() {
for(;;){
System.out.println(message);
}
}
}Oben wird Multithreading implementiert, indem die Runable-Schnittstelle geerbt wird, um run() zu implementieren, und Thread wird verwendet, um die virtuelle CPU zu implementieren, sodass Thread r1 in einem unabhängigen Thread ausgeführt werden kann. Tatsächlich sind dieser Thread und der Haupt-Thread keine völlig unabhängigen Threads. Stattdessen wechseln sich der R1-Thread und der Haupt-Thread ab. Die Wechselgeschwindigkeit ist jedoch sehr hoch und es sieht so aus, als würden zwei Threads unabhängig voneinander laufen.
2. Der Thread-Wechsel variiert je nach Betriebssystem:
Einer ist der Warteschlangenmechanismus, der wartet, bis der Thread seine Ausführung beendet oder passiv stoppt .
Einer geht durch den Prioritätsmodus, der Thread mit der höchsten Priorität erhält zuerst die CPU.
Eine davon ist die Zeitscheibe. Jeder Thread hat eine angemessene Zeitscheibe. Wenn ein Thread nach der Ausführung der Zeitscheibe beendet wird, haben andere Threads eine faire Chance, die CPU zu beanspruchen.
Java-Threads verfolgen einen umfassenden Ansatz, der auf Priorität und Zeitscheiben basiert. Die spezifische Implementierung variiert je nach Betriebssystem, auf dem sie ausgeführt werden. Wenn beispielsweise ein Thread die Ausführung seiner Zeitscheibe beendet hat, wird er beendet und seine Priorität um eine Ebene reduziert. Anschließend belegt der Thread mit einer höheren Priorität die CPU. Wenn während des laufenden Prozesses ein Thread mit einer höheren Priorität eintrifft, wird dies der Fall sein Besetzen Sie den aktuellen Thread.
3, Thread-Laufstatus:
Thread-Stopp (Pause) einschließlich Sleep(), Wait(), Suspend(), I/O-Blockierung
Thread-Neustart (Run ) beinhaltet Ruhezeitüberschreitung, notify(), resume(), E/A beendet
Thread-Beendigung, stop()
Thread-Warten, join()
Der Thread gibt aktiv die CPU auf, yield()
Die oben genannten suspend(), resume(), stop() sind veraltet und werden nicht mehr empfohlen.
4, Die Funktion „sleep()“ ist statisch und eine Funktion, die zu einer Klasse gehört, nicht zu einem Objekt. Diese Funktion bewirkt, dass der aufrufende Thread für einen bestimmten Zeitraum angehalten wird, anstatt einen anderen Thread zu stoppen. Wie folgt
publicstaticvoidmain(String[] args)throwsException {
SimpleRunnabler1 = new SimpleRunnable("Hello");
Threadt1 = newThread(r1);
t1.start();
for(inti = 0; i < 10; i++){
System.out.println("Bye-bye");
}
t1.sleep(10000);
t1.stop();
}Der obige Code stoppt den Hauptthread für 10 Sekunden, anstatt t1 für 10 Sekunden anzuhalten. Darüber hinaus ist die Zeit, die der Thread durch Sleep() angehalten wird, ein unscharfer Wert. Die obige Theorie führt jedoch dazu, dass der Hauptthread 10 Sekunden lang pausiert genau 10 Sekunden.
5. Eine weitere statische Funktion ist yield(), was bedeutet, dass der aktuell laufende Thread die CPU aktiv aufgibt. Diese Funktion kann nur auf den aktuellen Thread einwirken, ähnlich der obigen Funktion sleep().
6. Beim Programmieren geht es darum, effiziente Ergebnisse zu erzielen und Multithreading zu verwenden. Da Multithread-Operationen jedoch schwer vorherzusagen sind, werden wir bestimmte Methoden anwenden, um die Ergebnisse von Multithread-Operationen so vorhersehbar wie möglich zu machen.
class Thread1 extends Thread{
@Override
publicvoid run(){
try{
System.out.println("thread1 start");
sleep(10000); // <3>
System.out.println("thread1 finish");//<4>
}catch(Exception e){
}
}
}
class Thread2 extends Thread{
@Override
publicvoid run(){
try{
System.out.println("thread2 start");
suspend(); // <2>
System.out.println("thread2 finish");// <7>
}catch(Exception e){
}
}
}
publicclassThreadTest {
publicstaticvoid main(String[] args) {
Threadt1 = new Thread1();
Thread2t2 = new Thread2();
t1.start();
t2.start();
try{
System.out.println("s1");
t1.join(); // <1>
System.out.println("s2"); // <5>
t2.resume(); //<6>
System.out.println("s3"); // <8>
t2.join(); // <9>
}catch(Exception e){
}
System.out.println("s4"); // <10>
}
}Das Ergebnis eines der oben genannten Läufe ist:
Thread1 Start
Thread2 Start
s1
Thread1 Ende
s2
s3
Thread2 Finish
s4
Aber dieses Ergebnis erhält man nicht jedes Mal. Aber einiges davon ist vorhersehbar. Welche sind vorhersehbar? Welche sind unvorhersehbar?
(1) Die ersten drei Zeilen werden definitiv die ersten drei Zeilen belegen. Da der Code von <1> 10 Sekunden bei <3> Gleichzeitig bedeutet der Code bei <2>, dass Thread t2 in einem angehaltenen Zustand ist, bis es Code zum Aufwecken des Threads gibt, andernfalls bleibt der Thread blockiert. Die Ausgabereihenfolge der ersten drei Zeilen ist jedoch unvorhersehbar.
(2) Die vierte Zeile wird definitiv in der vierten Zeile sein, führen Sie den Code bei <4> aus In der fünften Zeile veranlasst der Hauptthread die Ausführung des Codes <5>
(4) Die Positionen der sechsten und siebten Zeile können vertauscht werden Code <6> weckt Thread t2 auf. Beginnen Sie dann mit der Ausführung von <7>, während der Hauptthread weiterhin ausgeführt wird <8>
(5) Die letzte Zeile wird definitiv die letzte Zeile sein. Halten Sie den Hauptthread bei <9> an, warten Sie auf das Ende von t2, führen Sie <10> aus, um die letzte Zeile auszugeben, und der Hauptthread endet und wird beendet.
