Java-Threads - Unterschied zwischen Sleep, Wait und Notify

Beide Methoden sleep() und wait() hält den aktuellen Thread an und setzt seinen Ausführungspfad nach einer Benachrichtigung fort, die nach einer bestimmten Zeit oder durch einen anderen Prozess ausgelöst wird.

wait kann von einem anderen Thread geweckt werden, der die notify. Es ist wichtig, dass wait et notify in einem Block aufgerufen werden synchronisiert die zur gegenseitigen Ausgrenzung verwendet wird. Die Methode notify weckt den ersten Prozess auf, der den wait.

Beispiel für wait() und notify()

In diesem Programm wird Prozess B innerhalb von Prozess A ausgeführt und erstellt eine gegenseitige Ausschlusszone, um Prozess A zu blockieren und daran zu hindern, die Anweisung nach dem Block auszuführen try/catch.

public class Thread_A {
 public static void main(String[] args) {
 
 Thread Thread_B = new Thread(new Runnable() {
 @Override
 public void run() {
 synchronized (this) {
 int i=0; 
 while(i< 100)
 i++; 
 //freier Faden A
 notify(); 
 }
 }
 }); 
 Thread_B.start(); 
 
 synchronized(Thread_B) {
 try {
 System.out.println("Thread A ist blockiert - Warten auf Thread B"+
 "zum Abschließen"); 
 //den A Thread_B.wait() in die Warteschleife setzen; 
 } catch (InterruptedException e) {
 // TODO Automatisch generierter catch-Block
 e.printStackTrace(); 
 }
 System.out.println("Thread B ist abgeschlossen - Thread A ist freigegeben"); 
 }
 }
}

Output

Thread A bleibt hängen Warten auf den Abschluss von Thread B
Thread B ist beendet. Thread A ist freigegeben

Beispiel für sleep()

Die Methode sleep() sperrt einen Prozess und führt ihn für eine bestimmte Zeit aus. Diese Methode wird für die Synchronisation mit der Zeit verwendet (z. B. Aufwachen nach 4 Sekunden) oder um Sleep zu sagen und andere Threads laufen zu lassen.

public class Sleep {

 public static void main(String[] args) {
 ThreadA a = new ThreadA(); 
 a.start(); 
 ThreadB b = new ThreadB(); 
 b.start(); 
 }

 statische Klasse ThreadA extends Thread{
 @Override
 public void run() {
 try {
 System.out.println("Thread A"); 
 Schlaf(4000); 
 System.out.println("Thread A: Ich habe 4 Sekunden geschlafen"); 
 } catch (InterruptedException e) {
 // TODO Automatisch generierter catch-Block
 e.printStackTrace(); 
 }
 }
 }
 
 statische Klasse ThreadB erweitert Thread{
 @Override
 public void run() {
 System.out.println("Thread B"); 
 int Summe = 0; 
 for(int i = 0 ; i < 50; i++)
 Summe +=i;
 System.out.println("Thread B: Ich bin fertig"); 
 }
 }
}

Output

Thread A
Thread B
Thread B: Ich habe fertig 
Thread A: Ich habe 4 Sekunden geschlafen

Prozess A wurde vor Prozess B gestartet, aber B hat die Verarbeitung durchgeführt, während Prozess A schlief und beendete die erste