9.11 Variablen mit volatile kennzeichnen
Die JVM arbeitet bei den Ganzzahl-Datentypen kleiner gleich int intern nur mit einem int. Doch obwohl es auch für die Datentypen, die größer als 32 Bit sind, also long und double, einzelne Bytecode-Befehle gibt, ist nicht gesichert, dass die Operationen auf diesen Datentypen unteilbar sind. Es kann also passieren, dass ein Thread mitten in einer long- oder double-Operation von einem anderen Thread verdrängt wird. Greifen zwei Threads auf die gleiche lange Variable zu, so könnte es passieren, dass der eine Thread eine Hälfte schreibt und der andere Thread die andere.
Beispiel Eine long-Variable l ist mit dem Wert 0x12345678 90abcdefL initialisiert. Aus Gründen der Übersichtlichkeit ist in der ersten Hälfte des long-Werts ein Leerzeichen eingefügt. Jetzt versuchen zwei Threads gleichzeitig die Variable zu ändern.
l = 0x00000000 00000000L; l = 0xabcdef12 34567890L;
Wenn hier der erste Thread den ersten Teil der long-Variablen mit 00000000 beschreibt, und dann ein Kontextwechsel stattfindet, ist die Variable fälschlicherweise mit 00000000 90abcdefL initialisiert. Kommt nun nach dem Kontextwechsel der zweite Thread, so kann dieser vielleicht auch nur den ersten Teil der Variable mit abcdef12 beschreiben, sodass danach die Variable den völlig krummen Wert abcdef12 90abcdefL enthält.
|
for ( int j = 0; j <= 1000; j++ )
i = j;
Eine optimierende Laufzeitumgebung könnte nun auf die Idee kommen, nicht bei jedem Schleifendurchlauf die Objektvariable zu erhöhen – denn das kostet zusätzliche Laufzeit –, sondern nur zu Beginn und am Ende der Schleife. Das heißt, es gilt lediglich eine Wertzuweisung zu machen, also i mit dem Wert 1000 zu belegen. Doch wenn der Prozessor Berechnungen im internen Speicher vornimmt und das Ergebnis nicht immer in den Variablen aktualisiert, kommt es zu schwer kontrollierbaren Nebeneffekten, denn womöglich wundern sich andere Threads über die abrupten Inkrements.
Auch hier hilft wieder das besondere Schlüsselwort. Ist die Variable mit volatile gekennzeichnet, wird das Ergebnis nicht im Zwischenspeicher belassen, sondern immer aktualisiert. Die parallelen Threads sehen somit immer den korrekten Variablenwert, da er vor jeder Benutzung aus dem Speicher gelesen und nach einer Änderung sofort wieder zurückgeschrieben wird.
Einsatz von volatile
Das Schlüsselwort volatile findet sich im Quellcode sehr selten und in der ersten Java-Beta-Version wurde es überhaupt nicht benutzt. Wenn wir eine andere Lösung suchen, dann können wir noch zu den Wrapper-Klassen greifen. Exemplare dieser Klassen haben im Gegensatz zu den elementaren Datentypen einen Monitor, der sich für die Synchronisation eignet. Für das long- und double-Problem ist das die einzige Lösung.
Beispiel Eine Laufzeitumgebung könnte den Zugriff auf Objektvariablen optimieren, indem zuerst die Variable in eine interne lokale Variable kopiert und anschließend das Ergebnis zurückgespeichert wird. Ist i eine Objektvariable, dann könnte folgende Schleife verbessert werden:
for ( int cnt = 0; cnt < 1000000; cnt++ )
i++;
Wenn die Umgebung zuerst i in eine lokale Variable kopiert, dann die gesamte Schleife ausführt und erst anschließend den Wert nach i zurückkopiert, haben wir viel Zeit gespart, denn der Zugriff auf eine lokale Variable, die im Register des Prozessors leben kann, ist wesentlich schneller als der Zugriff auf eine Objektvariable. Dies ist im Übrigen eine beliebte Strategie, um die Performance eines Programms zu steigern. Sie nutzt das Muster der Variablenzugriffe in dem Programmstück aus. Doch dadurch sind Änderungen am Wert von i nicht sofort für andere Threads sichtbar, denen damit die Information über die einzelnen Inkrementschritte fehlt.
|
Listing 9.14
VolatileDemo.java
class VolatileDemo extends Thread
{
/* volatile */ int i;
public void run()
{
while ( true )
{
for ( int cnt = 0; cnt < 1000000; cnt++ )
i++;
}
}
public static void main( String args[] )
throws InterruptedException
{
VolatileDemo t = new VolatileDemo();
t.start();
while ( true )
{
Thread.sleep( 1000 );
System.out.println( t.i );
}
}
}
|
