Threads

[Abbadon]

Hallo,
habe hier grade eine Aufgabe aber stehe grade vor eine Frage.
Dis Klasse heisst

public class Irgendwas ()

SO soll nun zwei Methode schreiben die erste Methode Thread sicher machen die zweite eine thread sichere Blockstruktur. Beide sollen den Monitor des Klassen Objektes aufrufen. So schaut mein code nun aus. er muss nicht laufen geht nur darum ob es so richtig wäre.

public class Irgendwas () {
             public static void main (String [] args) {
                 Irgendwas objekt = new Irgendwas();
              }
             
             public synchronized void ersteMethode(Irgendwas objekt) {
                   // Anweisungen
              }
             public void zweiteMethode () {
                 synchronized(objekt) {
                       //Anweisungen;
                  }
              }
}

So soweit so gut eine Methode und einen Block zu synchronizieren ist ja einfach. Beide Synchronizieren ja nun das Objekt der Klasse und zwar objekt.
Die frage lautet. Wie sieht ihre Klassendefinition aus, wenn sowohl die Thread-sichere Methode als auch die Thread-sichere Blockstuktur den Monitor des gleichen Objekts (nämlich eines Objektes der Klasse "Irgendwas" verwenden?)
Die frage die ich mir stelle was soll ich an der definition der Klasse ändern. Beide nehmen das Objekt der Klasse entgegene also was stimmt dann an der definition nicht?

Gruß Abbadon

 

[Der Müde Joe]

Eine Klassendefinition hat kein ().

Meist du so ein synch Block mit this?
Intrinsic Locks and Synchronization (The Java™ Tutorials > Essential Classes > Concurrency)

 

[Abbadon]

Ah die zwei klammern sollten bei der Klassen definition gar nicht mit dabei. ^^
Stimmt this ist ja immer ein verweis auf das Objekt.
Aber verweisst es dann auch auf das Klassen Objekt oder nur auf das Objekt aus dem Methoden Block?

public void text(String namen) {
             synchronized (this) {
                 //Anweisung;
             }
          }

Dann wird doch auf dieses Objekt also den String verwiesen und dessen Monitor angefordert oder sehe ich das Falsch?
Also wenn ich nun den Monitor des Klassenobjektes haben will müsste ich dann in der zweitenMethode auch ein Objekt der Klasse als Parameter angeben und damit dann auf this verweisen.
Bitte korrekieren wenn ich falsch liege

 

[hdi]

Also erstmal:

synchronized void blub(){
  ...
}

ist das selbe wie:

void blub(){
  synchronized(this){
       ...
  }
}

Mit den Parametern der Methode hat das gar nichts zu tun. D.h. in beiden Fällen: Du hälst das Lock auf "this", sprich keine andere synchronisierte Methode oder synchronisierter Block auf "this" kann ausgeführt werden, bis der Lock wieder frei ist.

Um auf den Bsp zurückzukommen:

 public synchronized void ersteMethode(Irgendwas objekt) {
                   // Anweisungen
              }
             public void zweiteMethode () {
                 synchronized(objekt) {
                       //Anweisungen;
                  }
              }

edit: Etwas verständlicher:

Beide Synchronizieren ja nun das Objekt der Klasse und zwar objekt.

NEIN! Das tut nur die zweite Methode, die erste synchronisiert auf "this". Und noch lustiger, wenn du die erste Methode wie folgt schreiben würdest:

public void ersteMethode(Irgendwas objekt) {
                  synchronized(objekt){...}
              }

dann würden sich hier noch immer nicht beide Methoden synchronisieren. Denn die erste synchronisiert auf das lokale Objekt, die zweite auf die Klassen/Instanz-Variable. In der ersten Methode wird diese vom lokalen gleichnamigen Objekt überschattet. Richtig wäre es dann erst so:

public void ersteMethode(Irgendwas objekt) {
                  synchronized(this.objekt){...} // this.objekt, also nicht das lokale vom Parameter
              }

 

[Der Müde Joe]

Wie schon mal gepostet. Im sun tutorial stets alles was man wissen sollte:
Lesson: Concurrency (The Java™ Tutorials > Essential Classes)

Grob zusammengefasst:
Jede Klasse besitzt einen Monitor.
Es gibt (um genau zu sein) 2 Monitore pro Klasse. Eine auf dem Objekt und eine auf dem Class Objekt das zum eigentlichen Objekt gehört(für static).

Ein Thread kann nun einen Monitor bekommen (aquire) und diesen auch wieder hergeben (release). Genau das passiert wenn der Thread in einen Synch-Statement oder in eine synch-Methode reingeht bzw verlässst.

Solange ein Thread einen Monitor sein eigenen nennen kann, sind alle anderen, welche den gleichen Monitor wollen am warten, bis der Besitzen ihn wieder frei gibt.

Das heisst, wenn du 2 nicht statische Methoden hast und beide synch sind, dass wenn ein Thread eine Methode benutzt, alle anderen synch Methoden gelocked sind. Der Monitor (des Objekts) ist im besitzt des Thread und keiner kriegt es bevor der Besitzer nicht released. Das selbe gilt für den synch(this)-Block. Wenn ein Thread da rein geht, bekommt er den Monitor auf this. Damit sind auch alle anderen Methode im lock drin, den das Objekt hat den Monitor bereits abgegeben.

 

[Abbadon]

Das ist ja klar das alle anderen Threads warten müssen bis der Monitor frei gegeben wird. Soweit habe ich das verstanden.
Nur wie kann man dann in zwei Methoden den Monitor der Klasse aufrufen? Sprich in der Methode und in dem Block?
Klar muss die Methode die den Monitor anfordert dazu veranlasst werden den Monitor frei zu geben damit der Thread in dem synchronisierten Block seine arbeit beginnen kann.
Also bin dabei Threads zu lernen wie das damit funktioniert.

ALso der Block ist ja nun Klar aber wie bekommt man den Monitor der Klasse auch in der Methode? Muss die Methode dann static sein oder das Objekt der Klasse static?
Also so

public class KlassenMonitor {
public static KlassenMonitor monitor;

public synchronized void methode(KlassenMonitor monitor) {
// Anweisung und freigabe
}
//oder so
public synchronized static void methode(KlassenMonitor monitor) {
// Anweisung und freigabe }

 

[hdi]

Vorab: Was ich jetzt schreibe will ich nicht zu 100% garantieren. Ich schreibe nur das, was ich glaube. Wenn du dir ganz sicher sein willst solltest du den o.g. Link durchlesen, dafür bin ich jetzt zu faul.

Bei Klassen musst du dann static verwenden, ja.
Wobei wieder gilt:

class MyClass{

public static synchronized void bla(){
     ...
}

/* das selbe wäre:
public static void bla(){
   synchronized(MyClass.class){
        ...
   }
}
*/

}

Dann hälst du das Lock der Klasse, d.h. alle statischen Methoden der Klasse sind für andere Threads gesperrt. Auf nicht-statische Methoden trifft das dann nicht zu.

 

[Marco13]

Vorab: Was ich jetzt schreibe will ich nicht zu 100% garantieren. ... weil ich eigentlich total übermüdet bin, und nicht sicher, ob ich das richtig verstanden habe, aber wenn du sagst

ALso der Block ist ja nun Klar aber wie bekommt man den Monitor der Klasse auch in der Methode? Muss die Methode dann static sein oder das Objekt der Klasse static?

dann klingt das nach sowas wie

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

wobei das seltsam aussieht, und ich so ein Knstrukt noch nie verwendet habe .. wozu auch :bahnhof:

 

[hdi]

@TO irgendwie denke ich auch dass wir inzwischen aneinander vorbei reden. Du benutzt vllt einfach eine falsche/andere Terminologie. Um nochmal deinen ursprünglichen Post aufzugreifen, denn das ist doch irgendwie noch immer deine Frage, oder?

So soweit so gut eine Methode und einen Block zu synchronizieren ist ja einfach. Beide Synchronizieren ja nun das Objekt der Klasse und zwar objekt.

Dass das nicht stimmt habe ich ja in einem vorherigen Post erklärt. Hast du das verstanden?

Die frage lautet. Wie sieht ihre Klassendefinition aus, wenn sowohl die Thread-sichere Methode als auch die Thread-sichere Blockstuktur den Monitor des gleichen Objekts (nämlich eines Objektes der Klasse "Irgendwas" verwenden?)
Die frage die ich mir stelle was soll ich an der definition der Klasse ändern. Beide nehmen das Objekt der Klasse entgegene also was stimmt dann an der definition nicht?

Und das hab ich eig. auch in dem o.g. Post erklärt, aber nochmal der Vollständigkeit halber, es müsste so aussehen:

public class Irgendwas () {
             public synchronized void ersteMethode() {
                   // Anweisungen
             }

             public void zweiteMethode () {
                   synchronized(this) {
                       // Anweisungen
                   }
              }
}

Das erste ist eine Thread-sichere Methode, das zweite eine Methode mit Thread-sicherer Blockstruktur. Wobei das eben in beiden Fällen das selbe ist, wie ich auch schon gesagt hatte.

So... ist das soweit klar? Und beantwortet das all deine Fragen? Das hat hier mit Synchronisierung von Klassen nichts zu tun, das ist Synchronisierung von Klassen-Instanzen, also Objekten. Aber das ist in deiner Aufgabenstellung gefordert. Willst du jetzt also wirklich noch irgendwas wissen über das Synchronisieren von ganzen Klassen?
Ich glaube halt wenn du von Klassen sprichst, meinst du Objekte.. Kann das sein?

 

[Der Müde Joe]

Und um dich nun noch ganz zu verwierren:

private Object monitorObject = new Object();
private byte[] monitor2 = new byte[0];

// benutzt als Monitor das monitorObject
// keine Methode, welche das gleiche Objekt als monitor
// benutzt, kann dann in den synch block rein
void foo() { synchronized(this.monitorObject){/*....*/}}

// benutzt als monitor den monitor2
void foo2() { synchronized(this.monitor2){/*....*/}}

// beider locks sind voeinander unabhängig

 

[Abbadon]

Danke euch erstmal,
ich würde mal sagen habe das jetzt so langsam verstanden mit dem Synchronisieren. Muss da noch ein bischen lernen und mal ein bischen damit arbeiten dann denke ich doch das es klappt.
Danke Vielmals auch für die Gedult.
Gruß