In diesem Artikel werden hauptsächlich relevante Informationen zur Implementierung des Thread-Wartevorgangs und der Benachrichtigung in Java vorgestellt. Ich hoffe, dass dieser Artikel jedem helfen kann, solche Funktionen zu beherrschen.
Implementierung von Thread-Warten und Benachrichtigungen in Java
Vorwort:
Die wichtigsten Punkte, die Sie beim Warten/Benachrichtigungen beachten sollten, sind:
Das Warten( ), notify(), notifyAll() Methoden müssen aus der Synchronisationsumgebung aufgerufen werden. Ein Thread kann keine Wait- oder Notify-Methoden für ein Objekt aufrufen, es sei denn, er besitzt eine Sperre für dieses Objekt.
wait(), notify(), notifyAll() sind alles Instanzmethoden von Object. So wie jedes Objekt eine Sperre hat, kann jedes Objekt eine Liste von Threads haben, die auf Signale (Benachrichtigungen) von ihm warten. Der Thread erhält diese Warteliste, indem er die Methode wait() für das Objekt ausführt. Von diesem Zeitpunkt an werden keine weiteren Anweisungen ausgeführt, bis die notify()-Methode des Objekts aufgerufen wird. Wenn mehrere Threads auf dasselbe Objekt warten, wird nur ein Thread ausgewählt (in keiner garantierten Reihenfolge), um die Ausführung fortzusetzen. Wenn keine Threads warten, wird keine besondere Aktion durchgeführt.
Beispielcode:
package threadwait;
public class ThreadA extends Thread{
public int num = 0;
public void run(){
synchronized (this){//在此类对象上实现同步，this指代当前对象
for(int i = 0 ; i < 3 ; ++i)
this.num+=i;
notifyAll();//通知所有在这个对象上等待的线程开始执行，在这里就是通知TestNotify主线程开始执行
}
}
public int getNum(){
return this.num;
}
}package threadwait;
public class TestNotify{
public static void main(String args[]){
ThreadA threada = new ThreadA();
threada.start();//threada线程有执行的资格，但是还没有开始执行
synchronized(threada){
try{
threada.wait();//主线程等待threada线程执行结束才开始执行
//而且只有获得了当前threada对象的锁之后才能执行wait，就是说在同步域内才可以执行wait，执行wait后放弃对象锁
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println(threada.getNum());
}
}Die Synchronisierung kann auf Klassenebene erfolgen, synchronisiert( A .class), es kann auch auf Objektebene synchronisiert werden (dies), es kann eine statisch synchronisierte Methode sein, statisch synchronisiert, die statisch synchronisierte Methode befindet sich auf Klassenebene und die nicht statische synchronisierte Methode befindet sich auf Klassenobjektebene , a Das Klassenobjekt hat nur eine Sperre. Erst wenn die Sperre erhalten wurde, kann der Wartevorgang ausgeführt und die Sperre dann aufgehoben werden.
Weiterer Beispielcode lautet wie folgt:
package threadwait;
public class ThreadA extends Thread{
public int num = 0;
public void run(){
synchronized (this){//在此类对象上实现同步，this指代当前对象
for(int i = 0 ; i < 3 ; ++i)
this.num+=i;
try{
Thread.sleep(500);//如果ThreadB的三个示例线程在还没有进入等待状态之前就受到了notifyall的信号
//那将会发生严重后果，因为调用notifyall的线程只可以调用一次notifyall，那造成等待的线程将永远等待下去
//所以在此处让它睡一小会，让其他线程有时间进入等待状态。
//不然会收到
}catch(InterruptedException e){
e.printStackTrace();
}
notifyAll();//通知所有在这个对象上等待的线程开始执行，在这里就是通知TestNotify主线程开始执行
}
// notifyAll();
}
public int getNum(){
return this.num;
}
}package threadwait;
public class ThreadB extends Thread{
private ThreadA threada;
public ThreadB(ThreadA ta){
this.threada = ta;
}
public void run(){
System.out.println(Thread.currentThread().getName()+" is waitting.");
synchronized(threada){
try{
threada.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" "+this.threada.getNum());
}
}
}package threadwait;
public class TestNotify{
public static void main(String args[]){
ThreadA threada = new ThreadA();
new ThreadB(threada).start();
new ThreadB(threada).start();
new ThreadB(threada).start();
threada.start();
}
}Das obige ist der detaillierte Inhalt vonSo implementieren Sie das Warten und Benachrichtigen von Threads in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
