# Funktionsweise von wait und notify



## saibot23 (21. August 2007)

Hallo,

ich habe folgendes Problem ich möchte einen Thread "bauen" der standard - mäßig schläft bis eine Methode dieses Threads von außen aufgerufen wird, dann soller aufwachen, etwas machen und sich wieder schlafen legen.

Ich bekomme zwar den Thread dazu, dass er einschläft (mit wait) aber er weckt mit notify nicht mehr auf.

Einschlafen:


```
synchronized (this) {
  try {
    this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
```

und das aufwecken in der Methode:


```
synchronized (this) {
this.notify();
}
```


----------



## philBerlin (21. August 2007)

Du brauchst einen Monitor, dh. ein Object, das Deinen Thread von außen steuert... 

das wait kommt in die run methode Deines Threads

```
public void run() {
  try {
    this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
```
ein Monitor kann es dann mit dieser Methode benachrichtigen...

```
synchronized (deinThread) {
notify();
}
```

grüße phil


----------



## saibot23 (21. August 2007)

ok danke hab es erstmal hinbekommen so, dass es läuft, aber mein Ziel hab ich noch nicht erreicht... Das war: es gibt einen Thread (der der schlafen gelegt und wieder geweckt werden soll...) und dieser Thead start selbst einen oder mehrere Threads (im meinem Fall ist es erstmal nur einer...). Wenn er diesen "Kindthread" gestartet hat, legt er sich schlafen und soll vom Kindthread geweckt werden wenn der Kindthread fertig ist... aber von diesem Kindthread lässt er sich nicht aufwecken...

Kann also der Kindthread nicht Monitor sein? und via 

```
synchronized(parentThread){
notify();
}
```

den ParentThread aufwecken?


----------



## limago (21. August 2007)

```
package de.tutorials;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MasterThread extends Thread {

	private static ExecutorService service = Executors.newCachedThreadPool();
	@Override
	public void run() {
		
		System.out.println("MasterThread start");
		
		synchronized (this) {
			service.execute(new ChildThread(this));
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		System.out.println("MasterThread ende");
		
	}
	
	
	public static void main(String[] args) {
		
		service.execute(new MasterThread());

	}
	
	class ChildThread implements Runnable {
		
		private MasterThread masterThread;

		ChildThread(MasterThread masterThread) {
			this.masterThread = masterThread;
		}

		@Override
		public void run() {
			try {
				System.out.println("ChildThread start");
				
				
				
				System.out.println("ChildThread ende");
			} finally { // Sicherstellen, dass Parent geweckt wird
			
				synchronized (masterThread) {
					masterThread.notify();
				}
			}
		
			
		}
		
	}
}
```


----------



## saibot23 (21. August 2007)

ah super, so ein Bsp hab ich gesucht ... danke


----------

