synchronized-Sclüsselwort: welche Reihenfolge zum Betreten?

[Guest]

Hallo!

Nach welcher Reihenfolge dürfen Threads einen synchronized-Block betreten?

Also etwa:

// hier warten 5 Threads
synchronized(this){
// code
}

Geht das nach FIFO, oder ist es unspezifiziert? Oder sonstwas?
Hab' schon die gängige Literatur abgeklapptert, in der Java Language Specification hab' ich dazu auch nichts gefunden.

Weiß das jemand von euch vielleicht? Wenn ja, bitte Quelle mit angeben.


Danke & Gruß!

 

[Illuvatar]

Ich weiß nicht ob das überhaupt festgelegt ist, wenn es selbst in der JLS nicht steht (ich hab nicht selbst nochmal nachgeschaut) spricht das dagegen. Folgender Test spricht aber eher für LIFO:

public class SyncTest extends Thread
{
  private int num;
  public SyncTest (int num) {
    this.num = num;
  }
  
  public void run() {
    System.out.println("Thread " + num + ": entering run");
    synchronized (getClass()) {
      System.out.println("Thread " + num + ": entering sync");
      sleep (3000);
      System.out.println("Thread " + num + ": leaving sync");
    }
  }

  public static void main(String[] args) {
    for (int i = 1; i <= 5; i++) {
      new SyncTest(i).start();
      sleep (500);
    }
  }
  
  public static void sleep (long ms) {
    try {
      Thread.sleep(ms);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      e.printStackTrace();
    }
  }
}

Thread 1: entering run
Thread 1: entering sync
Thread 2: entering run
Thread 3: entering run
Thread 4: entering run
Thread 5: entering run
Thread 1: leaving sync
Thread 5: entering sync
Thread 5: leaving sync
Thread 4: entering sync
Thread 4: leaving sync
Thread 3: entering sync
Thread 3: leaving sync
Thread 2: entering sync
Thread 2: leaving sync

Da wüd ich mich aber auch nicht drauf verlassen - schau dir lieber mal java.util.concurrent an, mit den Klassen da hast du eine größere Kontrolle.

 

[Guest]

Hallo!

Kann auch sein, dass ich es in der JLS überlesen habe.

Geht mir eigentlich nur darum, um die ungefähren Laufzeiten abzuschätzen.

Das ReentrantReadWriteLock bietet ja bspw. auch nur "approximately" FIFO wenn man's als Fair erstellt.

Danke trotzdem, und falls noch jemand was weiß: immer raus mit der Sprache! :wink:

Gruß

 

[André Uhres]

Nach welcher Reihenfolge dürfen Threads einen synchronized-Block betreten?

public final void notify()
Wakes up a single thread that is waiting on this object's monitor.
If any threads are waiting on this object, one of them is chosen to be awakened.
The choice is arbitrary and occurs at the discretion of the implementation.
A thread waits on an object's monitor by calling one of the wait methods.

 

[FArt]

Annahme: es verhält sich wie bei notify() und wait()... die Reihenfolge ist nicht festgelegt.

 

[diggaa1984]

so wie ich das bisher alles mitbekommen hatte bei meinen Übungen für die Uni, musst du einfach davon ausgehen das ein Thread an fast jeder Stelle unterbrochen werden kann, das kann direkt vor synchronized passieren oder sonst wo. Und welcher Thread dann dran ist und wie weit der kommt etc. das würde ich denken ist entweder JVM oder Betriebssystemabhängig, je nachdem wovon Java Thread-Scheduling und sone Späße abhängig macht.

Also meiner Meinung nach, wäre das quasi nicht vorhersagbar, welcher Thread wann da rein geht.

 

[didjitalist]

Das ist nicht nur deiner Meinung nach so Mit den einfachen Bordmitteln "synchronized" und "transient" kann man sicherstellen, dass Zugriff auf Resourcen atomar abläuft. Aber wenn man Kontrolle über die Abarbeitungsreihenfolge von Threads haben will, muss man wesentlich mehr Aufwand investieren. Java bietet dazu genug Mittel an - das package java.util.concurrent ist da sehr praktisch - aber man muss sich trotzdem selbst darum kümmern.