wait() and notify() mit mehreren Prozessen

[hanulli]

Hallo liebe Community;

Ich hab folgendes Problem:
Die Methoden wait() und notify müssen immer mit synchronisiert werden. Das Synchronisieren mach ich mit dem Befehl:
synchronized (object){ wait();}
Doch wie gestalte ich den diesen Befehl, bzw. welches object übergebe ich in diesem Befehl, wenn das Object -bzw, die Prozedur -, die dann später den notify()-befehl ausführt, zu dem Zeitpunkt der Initialisierung der wait() Methode noch nicht feststeht?

Ich hoffe, ihr habt meine Fragestellung verstanden! Falls nicht gebe ich noch ein kleines Beispiel:
Das folgende Programm erzeugt verschiedene Objekte namens Besucher1, Besucher2....! All diese Besucher wollen Recoder ausleihen, von denen es aber nur 10 Stück gibt. D.h., wenn mehrer als 10 Besucher zur gleichen Zeit ein Recoder wollen, müssen manche Besucher warten, bis die ersten Besucher wieder gehen:

import java.util.*;
public class verleih{
	 
	public static void main(String [] args){
		String name="Besucher";
		int i=0;
		while(true){
			try{
				
				int counter=0;
				for(int d=i;d>0;d/=10){
					counter++;
				}i++;
				name=name.substring(0,name.length()-counter);
				name+=i;
			Random ran=new Random();
			Thread.sleep(ran.nextInt(1000));
			}
			catch(InterruptedException e){}
			new besucher(name).start();
		}
		
		 
	}
}

import java.util.*;
public class besucher extends Thread{
	static int recoder=10;
	static int counter2=0;
	static Vector<besucher> besuch=new Vector();
	String name;
	long neededtime;
	public besucher(String name){
		this.name=name;
	}
	
public void run(){
	Random ran=new Random();
	while(recoder==0){
		try{
			synchronized (this){  

// Das Object this hier zu übergeben ist ganz falsch... Wie mach ich es richtig?

			System.out.println(name +" will jezt ein recorder");
			long start = new Date().getTime();
			besuch.add(this);
			wait();
			long runningTime = new Date().getTime() - start;
			neededtime+=runningTime;
			System.out.println("sequencetime"+ neededtime);
			
		}}
		
		catch(InterruptedException e){}
	}
		System.out.println(name+ " hat jetzt einen bekommen");
		recoder-=1;
		try{
		sleep(ran.nextInt(12000));
		}
		catch(InterruptedException e){}
	
		
			System.out.println(name+ " ist jetzt fertig");
		
		recoder++;
		if(!besuch.isEmpty()){
	synchronized (besuch.firstElement()){
		notify();
		counter2++;
		hans.remove(besuch.firstElement());
	}}
	}
	
	
}

Ich bin für jede Hilfe dankbar!

 

[Ebenius]

Du hast ganz allgemein einen Denkfehler. wait() und notify() gehören immer genau zu einem Objekt. Auf das selbe Objekt muss auch synchronisiert werden.

Wait

synchronized(object) {
  object.wait();
}

Notify

synchronized(object) {
  object.notify();
}

Falsch ist hingegen

synchronized(object) {
  wait(); // Hier müsste synchronized(this) benutzt werden
  notify(); // Hier müsste synchronized(this) benutzt werden
}

Exceptions habe ich in allen Beispielen absichtlich ignoriert.

Lies Dich am besten mal in das Java™ Tutorial: Concurrency ein. Der Aufwand lohnt.

Grüße, Ebenius

 

[hannulli]

Juhu;
Vielen Dank für deine Antwort, sie hat meine Frage im vollem Umfang beantwortet!

 

[hdi]

Ich hab dazu auch noch eine Frage:

Ist dann

public synchronized void foo(){...}

das gleiche wie

public void foo(){
      synchronized(this){...}
}

:?:

 

[hannulli]

wie du oben gesehen hast, hab ich nicht wirklich Ahnung...
Aber ich hab mich heute in das Thema reingearbeitet und bin zu dem Schluss gekommen, dass es definitiv nicht das Gleiche ist:
Deine erste Anweisung synchronisiert die Methode und die zweite Anweisung ein Objekt.

Ich hab mein oben angeführtes Beispiel jetzt mit synchronisierten Methoden umgeschrieben, da es mit Objekten ja nicht geklappt hat: Falls es dich interessiert, hier ist meine neue Version:
Vllt wird die bei diesem Programm der unterschied klar

import java.util.*;
public class verleih{
	 
	public static void main(String [] args){
		Schalter A=new Schalter();
		String name="Besucher";
		int i=0;
		while(true){
			try{
				
				int counter=0;
				for(int d=i;d>0;d/=10){
					counter++;
				}i++;
				name=name.substring(0,name.length()-counter);
				name+=i;
			Random ran=new Random();
			Thread.sleep(ran.nextInt(1000));
			}
			catch(InterruptedException e){}
			new besucher(name,A).start();
		}

import java.util.*;
public class besucher extends Thread{
	Schalter s;
	String name;
	public besucher(String name, Schalter s){
		this.name=name;
		this.s=s;
	}
	
public void run(){
	Random ran=new Random();
	s.ausleihen(name,this);
		
		try{
		sleep(ran.nextInt(12000));
		}
		catch(InterruptedException e){}
		s.giveback(name);
	}
	
}

import java.util.Date;
import java.util.Vector;


public class Schalter {
	static int counter2=0;
	static Vector<besucher> besuch=new Vector();
	
	static long neededtime;
	static int recoder=10;
	public synchronized void ausleihen(String name, besucher b) {
			while(recoder==0){
				try{
					
					System.out.println(name +" will jezt ein recorder");
					long start = new Date().getTime();
					besuch.add(b);
					wait();
					long runningTime = new Date().getTime() - start;
					neededtime+=runningTime;
					System.out.println("wholewaitingtime "+ neededtime);
					
				}catch(InterruptedException e){}
			}
				System.out.println(name+ " hat jetzt einen bekommen");
				recoder-=1;
		
	}
		public synchronized void giveback(String name){
			System.out.println(name+ "ist jetzt fertig");
			
			recoder++;
			if(!besuch.isEmpty()){
				synchronized (besuch.firstElement()){
					notify();
				}
				
				counter2++;
				besuch.remove(besuch.firstElement());
				}
		}
		}

 

[hdi]

Hm, ist mir nicht wirklich kar. Ich denk mir nach wie vor noch dass es das selbe ist.
Wäre gut wenn ein Profi das beantworten könnte

 

[Murray]

Deine erste Anweisung synchronisiert die Methode und die zweite Anweisung ein Objekt.

Das stimmt nicht; synchronisiert werden können immer nur Codeabschnitte.
Bei einer Instanzmethode ist

synchronized void foo() {
  /* Methodenrumpf */
}

tatsächlich äquivalent zu

void foo() {
  synchronized  ( this){
    /* Methodenrumpf */
  }
}

//EDIT: zweiten Codeabschnitt korrigiert

 

[hdi]

und bei einer statischen?

 

[Murray]

Da wird auf das Class-Objekt synchronisiert:

class Foo {
  static synchronized void foo() {
    /* Methodenrumpf */
  }
}

entspricht also

class Foo {
  static void foo() {
    synchronized ( Foo.class) {
      /* Methodenrumpf */
    }
  }
}

 

[hdi]

Hm wie genau kann ich mir das vorstellen? Genauso wie bei Instanzen, also werden dort dann auch alle statischen Variablen und Methoden geblockt?

 

[Murray]

Das ist alles kein Hexenwerk: ein Konstrukt

synchronized( xy) {
  /* irgendein Code */
}

(dabei ist xy irgendein Object)
stellt sicher, dass der gesamte Block in den geschweiften Klammern komplett durchlaufen wird, bevor in einem anderen Thread irgendein anderer Codeblock, der auf dasselbe Objekt xy synchronisiert, läuft.

Da werden keine Variablen irgendwie "geblockt" (was auch immer das bedeuten soll).

 

[hdi]

Naja Monitoring mit Semaphoren, das ist ja das Konzept das Java verwendet bei Synchronisation.
Da wird "geblockt", dadurch dass eine Lock-Variable gesetzt wird.

Aber es ist mir noch immer unklar: Bei statischen Methoden hat man ja kein Objekt.
Ich meine was ist wenn du in einer Klasse eine statische Methode hast, die synchronized ist,
und jetzt machst du dir eine Instanz dieser Klasse, und rufst eine nicht-statische Methode darauf auf.
Hat das was miteinander zu tun? Es läuft einfach darauf hinaus, dass ich mir auch gar nicht vorstellen
kann, wann man denn statische Methoden synchronisieren sollte. Vllt gibst du mir ein Beispiel? Dann
denk ich kann ich das leichter verstehen.

 

[Murray]

Wenn man eine Instanzmethode und eine statische Methode miteinander synchronisieren will ( = sicherstellen will, dass kein Thread eine der beiden Methoden bearbeiten kann, solange noch ein anderer Thread in einer der beiden Methoden steckt), dann ginge das so:

class Foo {
  static synchronized void foo1() {
    /* Methodenrumpf */
  }

  void foo2() {
    synchronized( getClass()) {
      /* Methodenrumpf */
    }
  }
}

Oder auch so:

class Foo {
  static final Object monitor = new Object();

  static void foo1() {
    synchronized( monitor) {
      /* Methodenrumpf */
    }
  }

  void foo2() {
    synchronized( monitor) {
      /* Methodenrumpf */
    }
  }
}

 

[Ebenius]

class Foo {
  static synchronized void foo1() {
    /* Methodenrumpf */
  }

  void foo2() {
    synchronized( getClass()) {
      /* Methodenrumpf */
    }
  }
}

Das ist falsch. Richtig wäre:

void foo2() {
  synchronized(Foo.class) {
    /* Methodenrumpf */
  }
}

Der Unterschied wird klar, wenn man sowas probiert:

new Foo(){}.foo2();

Ebenius

 

[Ebenius]

// EDIT: Doppelt. :-(