Java: Datenzugriffe mit dem Schlüsselwort volatile synchronisieren

Wer beim Schreiben von Multithreading-Anwendungen den Zugriff auf bestimmte Datenteile kontrollieren will, sollte das Schlüsselwort volatile kennen. ZDNet erklärt seinen Effekt - und die Unterschiede zu synchronized.

Ein Entwickler, der Multithreading-Anwendungen schreibt, muss manchmal den Zugriff auf bestimmte Datenteile in einer Klasse kontrollieren. Dazu dienst das Schlüsselwort synchronised. Weniger geläuftig ist hingegen das Schlüsselwort volatile. Es erzielt einen ähnlichen Effekt, und das ohne all den Overhead, den synchronized mit sich bringt.

Falls mehrere Threads Zugriff auf dieselbe Variable haben, wird die JVM vermutlich jedem Thread eine eigene Kopie der Variablen zugestehen. Änderungen an der Variablen durch einen Thread werden von anderen Threads bemerkt, womöglich aber auch nicht. Hier kommt der Vorteil von volatile gegenüber synchronised zum Tragen.

Mithilfe des Schlüsselworts volatile lässt sich der Zugriff auf eine Variable synchronisieren. Ist eine Variable als volatile deklariert, muss die JVM sicherstellen, dass alle zugreifenden Threads ihre Kopien aktualisieren, sobald die Variable geändert wird.

Ruft ein Thread synchronisierte Methoden oder Codeblocks auf, muss er den Lock des Objekts übernehmen. Verlässt der Thread den synchronisierten Code, muss der Lock wieder freigegeben werden. Das Übernehmen und Freigeben von Objekt-Locks erfordert Zeit und Ressourcen. Mithilfe des Schlüsselworts volatile lässt sich dieser Aufwand vermeiden.

Nachteile

Allerdings hat auch die Verwendung von volatile seinen Preis. Den Wert eines volatile-Feldes zwischen allen Threads synchronisiert zu halten, beansprucht ebenfalls Ressourcen. Am besten drückt es wahrscheinlich die Java-Spezifikation selbst aus: „Ein Feld kann als volatile deklariert werden. In diesem Fall muss ein Thread seine Arbeitskopie des Feldes jedes Mal, wenn er auf die Variable zugreift, mit der Masterkopie abgleichen.“

Wann das Schlüsselwort volatile zum Einsatz kommt und wann besser die synchronized-Methode, hängt von der jeweiligen Anwendung ab. Wer das nächste Mal einen Datenzugriff synchronisieren muss, sollte beide Optionen in Erwägung ziehen. Erst dann zeigt sich, welche von beiden die Aufgabe am besten erfüllt.

Themenseiten: Anwendungsentwicklung, Software

Fanden Sie diesen Artikel nützlich?
Content Loading ...
Whitepaper

ZDNet für mobile Geräte
ZDNet-App für Android herunterladen Lesen Sie ZDNet-Artikel in Google Currents ZDNet-App für iOS

Artikel empfehlen:

Neueste Kommentare 

7 Kommentare zu Java: Datenzugriffe mit dem Schlüsselwort volatile synchronisieren

Kommentar hinzufügen
  • Am 4. März 2009 um 15:35 von playmyskay

    "synchronised"
    In dem Artikel wird das Wörtchen "synchronised" erwähnt, jedoch im Zusammenhang mit Java beachte man bitte, dass das Schlüsselwort "synchronized", also mit "Z", geschrieben wird.

    Gruß

    • Am 4. März 2009 um 19:03 von Florian Kalenda, ZDNet

      AW: "synchronised"
      Herzlichen Dank für den Hinweis, ist korrigiert.

      • Am 28. März 2009 um 16:28 von playmyskay

        AW: AW: "synchronised"
        "Hier kommt der Vorteil von volatile gegenüber synchronised zum Tragen."

        So und jetzt nur noch in diesem Satz ändern und ich höre auf euch zu nerven ;-)

        • Am 1. Mai 2013 um 16:49 von Janmm14

          Wann wird das denn aktualisiert???

          • Am 13. Februar 2014 um 17:12 von Eric Becker

            ich warte immer noch darauf

  • Am 29. Juni 2013 um 17:02 von Andreas H

    Dieser Artikel vermittelt den Eindruck, dass volatile ähnlich wie eine Absicherung mit synchronized zur Synchronisierung eingesetzt werden kann. Das stimmt nicht!

    Wenn zwei Threads gleichzeitig eine als volatile markierte Variable bearbeiten, kann es zum Beispiel passieren, dass einer die Änderungen des anderen überschreibt.

  • Am 23. Juli 2013 um 18:25 von Raphael K

    Ich kann meinem Vorposter Andreas nur völlig Recht geben.
    Nur mal ein kleines Beispiel an den Autor ;) :

    class Number{
    static volatile int a = 0;

    public static void increment(){
    a++;
    }
    }

    Rufen jetzt 2 Threads die Methode increment gleichzeitig auf, so kann es sein, dass der Wert a = 1 ist. An dieser Stelle hilft mir „volatile“ nicht im geringsten bei der Synchronisation. An dieser Stelle müsste ich entweder ein „synchronized“ vor meine increment-Methode setzen, oder die Variable a als AtomicInteger deklarieren.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *