statische synchronisation

[hdi]

hallo,

ich les hier gerade eine vorlesung über java, und es geht um threads, race conditions, sowie synchronisation.
also ich verstehe schon das konzept von monitoren auf objekten in java.

jetzt hab ich mich aber gefragt: wie isn das bei statischen methoden, wenn man also quasi kein objekt hat? geht das überhaupt (darauf wird nämlich in der vorlesung nicht eingegangen)

ich hab mir dann mal folgendes programm geschrieben:

package tests;

public class Main {

    public static int count = 0;
    public static final int MAX = 1000000;

    public static void main(String[] args) {

        new CountThread("t1").start();
        new CountThread("t2").start();
    }
}

class CountThread extends Thread {

    String name;
    int ownCount;

    public CountThread(String string) {

        name = string;
        ownCount = 0;
    }

    @Override
    public void run() {

        increase();
    }

    public void increase() {
        while (Main.count < Main.MAX) {
            Main.count++;
            ownCount++;
        }

        System.out.println(name + ": ownCount " + ownCount + "  /   globalCount " + Main.count);
    }
}

ein ergebis der ausführung ergibt zB:

t2: ownCount 949775 / globalCount 1000000
t1: ownCount 946071 / globalCount 1000000

man sieht hier also deutlich die race condition. aber ich hab ne frage dazu:
die "globalCount" ist IMMER genau 1000000. Ich habe das Programm ca. 100 mal oder öfters getestet.
Erwartet hatte ich eigentlich, dass sie mal 1000001 ist oder noch etwas höher :/
Ist das jetz Zufall? Oder wieso ist es immer genau 1000000 ?

Also ich weiss nicht so recht, bin verwirrt..
Da es von der Syntax her in Java geht, eine statische Methode synchronized zu setzen, muss wohl eine Synchronisation über globale Variablen funktionieren. Aber wie? Oder irre ich mich doch?

dankeschön!

 

[shad0w]

Die Klasse ist in Java auch ein Objekt. Das bekommst du z.B. mit dem Ausdruck "Main.class" Wenn man eine statische Methode synchronisiert, wird auf diesem Klassen-Objekt synchronisiert.

Dass globalCount bei dir immer 1000000 ist, liegt an der Konstruktion deiner while-Schleife

        while (Main.count < Main.MAX) {
            Main.count++;
            ownCount++;
        }

Nach Ausführung der Schleife gilt natürlich: Main.count == Main.MAX

 

[hdi]

ja, aber Main.count sollte eben wegen race conditions NICHT immer Main.max sein, oder?

Bsp, nehmen wir an:

Main.count = 999999

Thread 1 überprüft die while-Bedingung:

(999999 < 1000000) => TRUE, ist in der schleife

jetzt kommt der scheduler und switcht die prozesse:

Thread 2 überprüft die while-Bedingung:

(999999 < 1000000) => TRUE, ist in der schleife

so, jetzt sind BEIDE in der schleife, wechsel zu thread 1 erhöht count, dann wechsel zu thread 2 erhöht count
auch, also Main.count == 1000001.

Jetz sag mir nich, dass ich nicht recht hab :noe: ^^

 

[shad0w]

Sorry, bin noch nicht ganz wach gewesen Natürlich kann globalCount auch 1000001 werden, das ist reiner Zufall. Erhöhe mal das Maximum auf 10000000, vielleicht siehst du es dann.

 

[hdi]

okay, aber das mit klassen synchronisieren hab ich jetz nich ganz verstanden.
was wird denn genau synchronisiert da? die instanzvariablen?

könntest du vllt meinen code umändern, sodass die globale variable Main.count synchronisiert wird,
dass also NICHT 1000001 rauskommen kann?

 

[shad0w]

Ich bin mir nicht ganz sicher, aber vllt ist es das, was du willst:

    public synchronized void increase() {
        synchronized (Main.class) {
            while (Main.count < Main.MAX) {
                Main.count++;
                ownCount++;
            }
        }
        System.out.println(name + ": ownCount " + ownCount + "  /   globalCount " + Main.count);
    }

Wenn ein Thread A nun in den synchronized-Block eintritt, dann bekommt er das Lock des Klassenobjekts Main (worin sich die statischen Variablen befinden). Während Thread A da drin ist, kann Thread B nicht den Block betreten, und muss solange warten, bis Thread A den Block verlassen hat. Erst dann führt Thread B den Block aus.

 

[shad0w]

Oops, das erste synchronized in der Methode gehört weg, so reicht es auch:

    public void increase() {
        synchronized (Main.class) {
            while (Main.count < Main.MAX) {
                Main.count++;
                ownCount++;
            }
        }
        System.out.println(name + ": ownCount " + ownCount + "  /   globalCount " + Main.count);
    }