Threading-Aufgabe. Totale Noob Fragen, aber bitte trotzdem beantworten ;)

[JasminM]

Hallo Leute, ich bin neu hier und bereite mich gerade auf eine Klausur vor. Ich hoffe ihr könnt mir helfen, da ich gerade vor lauter Bäumen den Wald nicht sehe:

Gegeben ist folgender Code:

public class CommonObjectV1 {
	public int counter = 0;
	public void printAndIncrement(String name){
		for (int i = 0; i < 5; i++){
			counter++;
			System.out.printlin(name + ": " + counter);
		}
	}
}

public class CommonObjectModifier {
	CommonObjectModifier(String name){
		this.modifierName = name;
	}
	
	public String modifierName;
	public static CommonObjectV1 common = new CommonObjectV1();
}

Jetzt soll man von CommonObjectModifier eine neue Klasse namens MultiThreadedCommonObjectModifier ableiten. Diese ist zum Teil gegeben und soll nur noch ergänzt werden:

public class MultiThreadedCommonObjectModifier{
	

	
	public void run(){
		common.printAndIncrement(modifierName);
	}

}

Meine Frage ist jetzt:

1. Die Klasse MultiThreadedCommonObjectModifier darf laut Eclipse nicht von CommonObjectModifier vererben (also "extends CommonObjectModifier" ist ungültig) und erbt jetzt nur von der Superklasse "Thread" (aufgrund der run()-Methode). Aber wieso? In der Aufgabenstellung steht ja, dass es von Com... erben soll.

2. Die Klasse CommonObjectModifier verlangt jetzt einen String. Wie übergebe ich diesen String dieser Klasse über MultiThre...?

3. Diese Klasse CommonOb... erzeugt eine neue Instanz von CommonObjectV1, auf die run()-Methode dann zugreift. Das ist dann ja der kritische Bereich. Hab ich das richtig verstanden?

Ist ein bisschen länger her, dass ich etwas programmiert habe, deswegen seid mir ein wenig nachsichtig.

 

[JasminM]

Ok, ich glaub ich hab es teilweise:

Meine MultiThreadedCommonObjectModifier-Klasse wäre:

public class MultiThreadedCommonObjectModifier extends CommonObjectModifier implements Runnable{
	

	
	
	
	MultiThreadedCommonObjectModifier(String name) {
		super(name);

	}
	

	public void run(){
		common.printAndIncrement(modifierName);
	}

}

 

[Hutzli]

haha hat das ein Lehrer von dir geschrieben? ^^

 

[Hutzli]

Versuche es jetzt mal trotzdem.
Der kritische Bereich befindet sich in der printAndIncrement Methode wo du den counter veränderst, da deine CommonObjectV1 Instanz static ist. Es gibt also nur eine für sämtliche Instanzen von deiner Klasse CommonObjectModifier. Wenn du jetzt mehrere dieser Threads gleichzeitig startest, wird immer dieselbe printAndIncrement Methode aufgerufen und dementsprechend derselbe counter erhöht, beziehungsweise Code durchgeführt. Mach mal diese print Methode synchronized, damit verhinderst du, dass mehrere Threads gleichzeitig darauf zugreifen (Vielleicht reicht es auch, wenn du nur die Mutation des Counters auf synchronized stellst, bin mir da nicht ganz sicher).
Ich verstehe nicht ganz, was dieses Beispiel aussagen soll, geschweige denn ist der Code grauenhaft.

 

[JasminM]

Vielen lieben Dank.

Das Beispiel ist aus einer ehemaligen Klausur. Und die Vorschläge von dir werden in darauf folgenden Fragen nochmal erläutert.

Kannst du mir sagen, was das "static" genau macht? Was würde passieren, wenn man es weglässt?

 

[Hutzli]

Also, mit static definierst du eine Klassenvariable oder eine Klassenmethode.
Das bedeutet, du musst in deinem Beispiel keine Instanz von CommonObjectModifier erzeugen, um darauf zuzugreifen: CommonObjectModifier.common (Aufruf von common).
Für jede deiner Instanz von CommonObjectModifier ist das Objekt common immer dasselbe.
Wenn du static weglässt, wird das common Objekt immer neu erzeugt, jede Instanz hat demnach ein eigenes Objekt.

Hier ein Beispiel (Kopiers mal und führ es aus, hilft bestimmt dem Verständnis):

public class ObjectWithStatic
{
	// Counter wird genau einmal erzeugt und ist ohne Objekterzeugung zugänglich.
	// Jede Instanz wird denselben counter hochzählen, da static.
	public static int smCounter = 0;
	
	// Dieser counter wird für jede Instanz neu erstellt.
	// Jede Instanz hat einen eigenen counter.
	// Um darauf Zugriff zu erhalten, muss ein Objekt von dieser Klasse erzeugt werden.
	private int mCounter;
	
	private String mName;
	
	public ObjectWithStatic( String pName )
	{
		this.mCounter = 0;
		this.mName = pName;
	}
	
	public void increment()
	{
		for( int i = 0; i < 5; i++ )
		{
			mCounter++;
			smCounter++;
			System.out.println("Object: " + mName + " InstanzCounter: " + mCounter + "   ClassCounter: " + smCounter );
		}
	}
}

public class TestStatic
{
	public static void main( String[] args )
	{
		// Zugriff ohne Instanziierung. Ausgabe 0
		System.out.println( ObjectWithStatic.smCounter );
		
		// Zwei Objekte erzeugen.
		ObjectWithStatic lStatic1 = new ObjectWithStatic( "Obj1" );
		ObjectWithStatic lStatic2 = new ObjectWithStatic( "Obj2" );
		
		// Inkrementiere counter von obj1 und Klassencounter hoch
		lStatic1.increment();
		// Inkrementiere counter von obj2 und Klassencounter hoch
		lStatic2.increment();
		
		// Wird 10 geben, da jedes deiner Objekte denselben Counter hochzählt
		System.out.println( ObjectWithStatic.smCounter );

	}

}

Durch static wird also aus jedem deiner Threads dasselbe Objekt aufgerufen, dadurch wird auch derselbe counter hochgezählt. Würdest du static weglassen, dann würde für jedes deiner Objekte also auch ein neues CommonObjectV1 erzeugt. Statische Member benutzt man übrigens zum Beispiel um die Instanzen einer Klasse zu zählen. Also ein static counter, der im Konstruktor hochgezählt wird.

Hoffe, dass das so verständlich genug ist

 

[JasminM]

Wow, vielen Dank. Durch dein Beispiel ist es mir klar geworden.

 

[Hutzli]

super