Heim >Java >javaLernprogramm >Zusammenfassung der Grundkenntnisse über Java-Multithreading (mit Code)
Zusammenfassung der Grundkenntnisse über Java-Multithreading (mit Code)
- 不言nach vorne
- 2019-02-21 14:31:042839Durchsuche
Der Inhalt dieses Artikels ist eine Zusammenfassung der Grundkenntnisse über Java-Multithreading (mit Code). Ich hoffe, dass er für Sie hilfreich ist.
Name des Java-Hauptthreads
Ein Programm, das wir starten, kann als Prozess verstanden werden, der einen Hauptthread enthält, und ein Thread kann als Unteraufgabe verstanden werden. Java Sie können den Standard-Haupt-Thread-Namen über den folgenden Code abrufen:
System.out.println(Thread.currentThread().getName());
Das laufende Ergebnis ist „main“, also der Name des Threads und nicht die „main“-Methode.
Zwei Möglichkeiten, Threads zu erstellen
1. Erben Sie die Thread-Klasse
public class Thread1 extends Thread {
@Override
public void run() {
System.out.println("qwe");
}
}
2. Implementieren Sie die Runnable-Schnittstelle
public class Thread2 implements Runnable {
@Override
public void run() {
System.out.println("asd");
}
}
Thread-Implementierungen Wenn die Runnable-Schnittstelle in mehreren Threads ausgeführt wird, hat die Ausführungsreihenfolge des Codes nichts mit der Aufrufreihenfolge zu tun. Außerdem gilt: java.lang.IllegalThreadStateException
currentThread-Methode
gibt zurück, von welchem Thread der aktuelle Code verarbeitet wird.
public class Thread1 extends Thread {
public Thread1() {
System.out.println("构造方法的打印：" + Thread.currentThread().getName());
}
@Override
public void run() {
System.out.println("run 方法的打印：" + Thread.currentThread().getName());
}
}
Thread1 thread1 = new Thread1(); thread1.start();
isAlive-Methode
um festzustellen, ob der aktuelle Thread aktiv ist.
public class Thread1 extends Thread {
@Override
public void run() {
System.out.println("run 方法的打印 Thread.currentThread().isAlive() == " + Thread.currentThread().isAlive());
System.out.println("run 方法的打印 this.isAlive() == " + this.isAlive());
System.out.println("run 方法的打印 Thread.currentThread().isAlive() == this.isAlive() == " + (Thread.currentThread() == this ? "true" : "false"));
}
}
Thread1 thread1 = new Thread1();
System.out.println("begin == " + thread1.isAlive());
thread1.start();
Thread.sleep(1000);
System.out.println("end == " + thread1.isAlive());
Die Ausführungsergebnisse sind wie folgt:
begin == false run 方法的打印 Thread.currentThread().isAlive() == true run 方法的打印 this.isAlive() == true run 方法的打印 Thread.currentThread() == this == true end == false
thread1 wird nach 1 Sekunde ausgeführt. Das Ausgabeergebnis ist also falsch. Und Thread.currentThread() ist dasselbe Objekt Das Ausführen der aktuellen Ausführungsmethode ist uns selbst (dies).
Wenn das Thread-Objekt als Parameter erstellt wird Wenn die Methode für start() an das Thread-Objekt übergeben wird, unterscheidet sich das Ausführungsergebnis vom vorherigen Beispiel. Der Grund für diesen Unterschied liegt immer noch im Unterschied zwischen Thread.currentThread() und this.
System.out.println("begin == " + thread1.isAlive());
//thread1.start();
// 如果将线程对象以构造参数的方式传递给 Thread 对象进行 start() 启动
Thread thread = new Thread(thread1);
thread.start();
Thread.sleep(1000);
System.out.println("end == " + thread1.isAlive());
Ausführungsergebnis
begin == false run 方法的打印 Thread.currentThread().isAlive() == true run 方法的打印 this.isAlive() == false run 方法的打印 Thread.currentThread() == this == false end == false
Thread.currentThread().isAlive() ist wahr, weil Thread.currentThread () gibt ein Thread-Objekt zurück, und wir verwenden dieses Objekt auch, um den Thread zu starten, sodass es sich im aktiven Zustand befindet.
This.isAlive() ist leichter zu verstehen, wenn es falsch ist, da wir das ausführen run-Methode durch den vom Thread-Objekt gestarteten Thread. Dies bedeutet auch, dass die beiden nicht dasselbe Objekt sind.
sleep-Methode
setzt den aktuellen „ausführenden Thread“. Der „ausführende Thread“ muss der von Thread.currentThread() zurückgegebene Thread sein Dies geschieht, bevor der Thread die Aufgabe abschließt, das heißt, den aktuellen Vorgang aufzugeben. In Java gibt es die folgenden drei Methoden >Verwenden Sie das Exit-Flag, um den Thread normal zu beenden, d wird nicht empfohlen.
Verwenden Sie die Interrupt-Methode, um den Thread zu unterbrechen.
- Threads, die nicht gestoppt werden können
-
Aufrufen des Die Interrupt-Methode markiert nur den aktuellen Thread als stoppend und stoppt ihn nicht tatsächlich.
Thread.sleep(1000);
public class Thread1 extends Thread { @Override public void run() { for(int i = 0; i < 500000; i++) { System.out.println(i); } } }Wir rufen die Interrupt-Methode zwei Sekunden später auf. Anhand der gedruckten Ergebnisse können wir sehen, dass der Thread nicht gestoppt wurde. , aber nach 500.000 Ausführungen dieser Schleife endet die Ausführungsmethode und der Thread stoppt - Bestimmen Sie, ob der Thread gestoppt ist
- Nachdem wir das markiert haben Wenn der Thread gestoppt ist, müssen Sie feststellen, ob es sich bei dem Thread um eine Stoppmarke innerhalb des Threads handelt. Wenn ja, stoppen Sie den Thread.
this.isInterrupted();
Das Folgende ist die Quelle Code der beiden Methoden:
Thread1 thread1 = new Thread1(); thread1.start(); Thread.sleep(2000); thread1.interrupt();Statische Methode der Methodendaten, dh um festzustellen, ob der aktuelle Thread unterbrochen wurde.
- Von der offiziellen Website
Methodenfokus
Thread Der Interrupt-Status wird durch diese Methode gelöscht. Mit anderen Worten, wenn diese Methode zweimal hintereinander aufgerufen wird, gibt der zweite Aufruf „false“ zurück hat seinen Interrupt-Status gelöscht und der zweite Aufruf hat den Interrupt-Status zuvor überprüft, außer wenn der aktuelle Thread erneut unterbrochen wird). - Thread ausnahmsweise stoppen
public static boolean interrupted() { return currentThread().isInterrupted(true); } public boolean isInterrupted() { return isInterrupted(false); }public class Thread1 extends Thread { @Override public void run() { try { for (int i = 0; i < 500000; i++) { if (this.isInterrupted()) { System.out.println("线程停止"); throw new InterruptedException(); } System.out.println("i = " + i); } } catch (InterruptedException e) { System.out.println("线程通过 catch 停止"); e.printStackTrace(); } } }Das Ergebnis ausgeben, diese sind die letzten paar Zeilen:
Thread1 thread1 = new Thread1(); thread1.start(); Thread.sleep(1000); thread1.interrupt();
Ersetzen durch
. Der Thread kann auf die gleiche Weise beendet werdeninterrupted()Stopp im SchlafisInterrupted()
-Methode aufruft, um den Thread in den Ruhezustand zu versetzen, wird später eineDer Thread wird gewaltsam gestoppt Mit derinterrupted()-Ausnahme ausgelöst.i = 195173 i = 195174 i = 195175 线程停止 线程通过 catch 停止 java.lang.InterruptedException at Thread1.run(Thread1.java:9)
-Methode kann der Thread gewaltsam gestoppt werden. Diese Methode ist jedoch veraltet und wird aus den folgenden Gründen nicht empfohlen.
即刻抛出 ThreadDeath 异常, 在线程的run()方法内, 任何一点都有可能抛出ThreadDeath Error, 包括在 catch 或 finally 语句中. 也就是说代码不确定执行到哪一步就会抛出异常.
释放该线程所持有的所有的锁. 这可能会导致数据不一致性.
public class Thread1 extends Thread {
private String userName = "a";
private String pwd = "aa";
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
@Override
public void run() {
this.userName = "b";
try {
Thread.sleep(100000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.pwd = "bb";
}
}
Thread1 thread1 = new Thread1(); thread1.start(); Thread.sleep(1000); thread1.stop(); System.out.println(thread1.getUserName() + " " + thread1.getPwd());
输出结果为:
b aa
我们在代码中然线程休眠 Thread.sleep(100000); 是为了模拟一些其它业务逻辑处理所用的时间, 在线程处理其它业务的时候, 我们调用 stop 方法来停止线程.
线程是被停止了也执行了 System.out.println(thread1.getUserName() + " " + thread1.getPwd()); 来帮我们输出结果, 但是 this.pwd = "bb"; 并没有被执行.
所以, 当调用了 stop 方法后, 线程无论执行到哪段代码, 线程就会立即退出, 并且会抛出 ThreadDeath 异常, 而且会释放所有锁, 从而导致数据不一致的情况.
interrupt 相比 stop 方法更可控, 而且可以保持数据一致, 当你的代码逻辑执行完一次, 下一次执行的时候, 才会去判断并退出线程.
如果大家不怎么理解推荐查看 为什么不能使用Thread.stop()方法？ 这篇文章. 下面是另一个比较好的例子.
如果线程当前正持有锁(此线程可以执行代码), stop之后则会释放该锁. 由于此错误可能出现在很多地方, 那么这就让编程人员防不胜防, 极易造成对象状态的不一致. 例如, 对象 obj 中存放着一个范围值: 最小值low, 最大值high, 且low不得大于high, 这种关系由锁lock保护, 以避免并发时产生竞态条件而导致该关系失效.
假设当前low值是5, high值是10, 当线程t获取lock后, 将low值更新为了15, 此时被stop了, 真是糟糕, 如果没有捕获住stop导致的Error, low的值就为15, high还是10, 这导致它们之间的小于关系得不到保证, 也就是对象状态被破坏了！
如果在给low赋值的时候catch住stop导致的Error则可能使后面high变量的赋值继续, 但是谁也不知道Error会在哪条语句抛出, 如果对象状态之间的关系更复杂呢？这种方式几乎是无法维护的, 太复杂了！如果是中断操作, 它决计不会在执行low赋值的时候抛出错误, 这样程序对于对象状态一致性就是可控的.
suspend 与 resume 方法
用来暂停和恢复线程.
独占
public class PrintObject {
synchronized public void printString(){
System.out.println("begin");
if(Thread.currentThread().getName().equals("a")){
System.out.println("线程 a 被中断");
Thread.currentThread().suspend();
}
if(Thread.currentThread().getName().equals("b")){
System.out.println("线程 b 运行");
}
System.out.println("end");
}
}
try{
PrintObject pb = new PrintObject();
Thread thread1 = new Thread(pb::printString);
thread1.setName("a");
thread1.start();
thread1.sleep(1000);
Thread thread2 = new Thread(pb::printString);
thread2.setName("b");
thread2.start();
}catch(InterruptedException e){ }
输出结果:
begin 线程 a 被中断
当调用 Thread.currentThread().suspend(); 方法来暂停线程时, 锁并不会被释放, 所以造成了同步对象的独占.
Das obige ist der detaillierte Inhalt vonZusammenfassung der Grundkenntnisse über Java-Multithreading (mit Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!