warum schließt synchronized andere threads nicht aus?

[braindoc]

Hallo zusammen,

ich habe probleme synchronized anzuwenden. ich hatte auch einen anderen thread dazu gefunden (http://www.java-forum.org/java-basics-anfaenger-themen/74919-threads-synchronized-mach.html) aber der war geschlossen, deswegen habe ich mal einen neuen thread aufgemacht... ich denke ich habe ein ähnliches Problem wie in dem Oben genannten Tread, aber ich komme noch nicht so ganz dahinter....

folgender Code

class P implements Runnable {
   Thread t;

   P(int id) { //Konstruktor
      t = new Thread(this, "P"+id);
      System.out.println("Child thread created:" + t);
      t.start(); 
   }

   public void run() { 
       int counter=0;
       while(counter<1)
       {
        task1();
        task2();
        task3()
        task4();
        counter++;

       }

       System.out.println("child killed");
   }

   public synchronized void task2()
       {
            System.out.println(Thread.currentThread().getName()+" started sync-area");
            doSth(); //beschäftigung
            System.out.println(Thread.currentThread().getName()+"   stopped sync-area");
       }

   public void task1(){
      //...
   }

   public void task3(){
      //...
   }
   
   public void doSth()
   {
    // hier steht die beschäftigung (mehrere verschachtelte schleifen, aber kein sleep oder wait!)
   }
}

class Main {
   public static void main(String args[]) {
      new P(1); // create a new thread
      new P(2); // create a new thread
      new P(3); // create a new thread
      new P(4); // create a new thread
      new P(5); // create a new thread
   }
}

in der Ausgabe steht in ungefäht folgendes:

P1 started sync-area
P2 started sync-area
P3 started sync-area
P4 started sync-area
P5 started sync-area
P1 stopped sync-area
P2 stopped sync-area
P3 stopped sync-area
P4 stopped sync-area
P5 stopped sync-area

(plus noch einige andere ausgaben aus anderen Methoden...)

?! aber task2 ist doch synchronized, sollte also nur von einem Thread gleichzeitig ausgeführt werden? wie kann es sien das er die Methode frühlich parallel ausführen lässt?
in dem o.g. Thrad wird vorgeschlagen das man auf ein objekt oder so ähnlich synchronisieren soll. Mir ist nur noch nicht so ganz klar warumm? Mit [c]public synchronized void task2()[/c] habe ich doch gesagt das die methode nicht nebenlaufig ausgeführt werden darf?

Vielen Dank für die Tipps... braindoc

 

[Michael...]

In Deinem Code Bsp werden fünf P Objekte erzeugt und daran jeweils die fünf task2 Methoden aufgerufen. Da hier also auf unterschiedliche Objekte bzw. deren Methode zugeriffen wird, hat das synchronized keine Auswirkung.
Galileo Computing :: Java ist auch eine Insel – 14.5 Synchronisation über kritische Abschnitte

 

[braindoc]

oaky, vielen Dank für die Erklärung.

Aber ich stehe auf dem Schlauch. Ich habe sogar genau das verlinkte Buch vor mir leigen ...

Vieleicht kann mich jem. auf meinen Denkfehler hinweisen:

Synchronized verhindert doch das nebenlaufig auf die Methode zugegriffen wird. Und nebenläufige Zugriffe erhalte ich doch nur wenn ich mehrere unterschiedliche Threads erstelle, oder? Also muss ich doch 5 unterschiedliche Threads erstellen!

Wenn ich dich richtig verstanden habe, kann synchronized nur innerhalb eines Threads arbeiten und nicht mit unterschiedlichen Threads ("Da hier also auf unterschiedliche Objekte bzw. deren Methode zugeriffen wird, hat das synchronized keine Auswirkung.")

Was hat es denn für einen Sinn wenn synchronized nur innerhalb eines Threads synchronisiert?! da kann doch garkeine Nebenlaufichkeit entstehen?


ich hoffe irgendjemand versteht meine denkensweise :-/

 

[eRaaaa]

Normal hast du ja das synchronized nicht in den Thread-Methoden, sondenr eben in den Klassen/Objekten die du den Threads beifügst / mit welchen die Threads arbeiten
Wenn du z.B. einen Stack hast der von mehreren Threads bearbeitet werden soll, dann müssen eben unter Umständen die Methoden des Stacks synchronisiert sein!
Wie Michael... schon schrieb, hast du hier aber verschiedene P-Objekte!
Vlt wird es für dich klarer wenn wir deinen Code etwas umändern:
In Zeile 3 einfügen

	static Object lock = new Object();

Und die Methode task2 wie folgt ändern

	public void task2() {
		synchronized (lock) {
			System.out.println(Thread.currentThread().getName()
					+ " started sync-area");
			doSth(); // beschäftigung
			System.out.println(Thread.currentThread().getName()
					+ "   stopped sync-area");
		}
	}

hier wird jetzt explizit auf das Objekt lock der Monitor gelegt
Da bei allen Objekten das Objekt lock das selbe ist (da static) sollte das dann so auch funktionieren.
In deinem Code, also bei synchronized in der Methodensignatur, sagst du ja, dass der Monitor auf this(also auf der p-Instanz gelegt werden soll)
Aber eig. steht das auch alles im og.g. Link, von daher :bahnhof:

 

[Michael...]

Da hast Du mich falsch verstanden. Dein Konstrukt ist zum Testen von synchronized etwas "ungünstig".
Du erzeugst fünf Runnable Objekte, deren run zwar in verschiedenen Threads läuft, die aber nur auf ihre eigene task2 Methode zugreifen.
D.h. es wird nirgends versucht gleichzeitig auf ein und die selbe task2 Methode zu zugreifen, da jeder Thread seine "eigene" Methode ausführt.

Um die Auswirkung von synchronized nachzuvollziehen. Müsstest Du ein Objekt mit einer synchronized Methode erstellen und dieses allen fünf Threads übergeben.

 

[braindoc]

oaky, nochmal danke das ihr euch so mühe gebt, ich denke es dämmert - aber auch nur das. Hell ist es irgendwie noch nicht geworden...

wenn ich mehrere Instanzen/Objekte erzeige haben die alle ihre eigenen task2-methoden. Soweit klar. Und genau bei diesen einzelnen task2 Methoden will ich ja verhindern das sie nebenlaufig abgearbeitet werden.
Der Vorschlag mit dem Lock objekt leuchtet soweit (eigendlich) auch ein.

@ eRaaaa
"Normal hast du ja das synchronized nicht in den Thread-Methoden, sondenr eben in den Klassen/Objekten die du den Threads beifügst / mit welchen die Threads arbeiten"
--> vieleicht liegt da ja mein Fehler. Ich dachte das task2 eine Methode eines P-Objekts ist. ???:L Und mit diesen Objekten arbeiten doch die Threads, das scheint ja genau der punkt zu sein den ihr mir gerade beibringen wollt (unterscheidliche Threads, unterschiedliche Objekte)?

@ Michael
"Dein Konstrukt ist zum Testen von synchronized etwas "ungünstig"."
--> offensichtlich Aber was währe dann eine günstigeres Konstrukt? In dem Inselbuch steht [c] synchronized void foo() { i++; } [/c], womit verhindert wird das das nicht-atomare i++ nicht nebenlaufig ausgeführt wird, damit es zu keinen Race-conditions kommt. - Das scheit aber mit [c] synchronized void task2() { ... } [/c] nicht zu funktionieren ?! ???:L

"es wird nirgends versucht gleichzeitig auf ein und die selbe task2 Methode zu zugreifen"
--> soweit verstanden, es sind unterschiedliche Methoden, da unterschieldiche Threads. Aber wenn jeder Thread seine eigene Methoden hat, kann es ja garnicht zu ungewollten nebenlaufichkeitsefekten kommen. Aber wozu kann ich Methoden dann mit synchronized versehen?

Ich will euch nicht unnötig arbeit machen, aber könnte jem. vieleicht so umändern das synchronized methoden Sinn machen?

 

[eRaaaa]

:autsch:

class P {
	
	public synchronized void task2() {
		System.out.println(Thread.currentThread().getName()
				+ " started sync-area");
		doSth(); // beschäftigung
		System.out.println(Thread.currentThread().getName()
				+ "   stopped sync-area");
	}

	public void doSth() {
		// hier steht die beschäftigung (mehrere verschachtelte schleifen, aber
		// kein sleep oder wait!)
	}
	
	public static void main(String[] args) {
		final P p = new P();
		
		//erstelle drei threads die mit dme p objekt arbeiten
		new Thread(new Runnable() {
			public void run() {
				p.task2();
			}
		}).start();
		new Thread(new Runnable() {
			public void run() {
				p.task2();
			}
		}).start();
		new Thread(new Runnable() {
			public void run() {
				p.task2();
			}
		}).start();
	}
}

 

[braindoc]

okay, manchmal dauerts ein bisschen länger... aber ich glaub nun hab auch ich's verstanden!
Danke für eure Hilfe :toll: