Thread-Schreibe-Lese-Problem

[Adriano10]

class KontoSL {

    private int kontostand;

    private int summeBarEinzahlungen;

    private int summeUeberweisungsEinzahlungen;

    KontoSL() {
        this.kontostand = 0;
        this.summeBarEinzahlungen = 0;
        this.summeUeberweisungsEinzahlungen = 0;
    }

    void barEinzahlen(int betrag) {
        this.summeBarEinzahlungen = this.summeBarEinzahlungen + betrag;
        // Problem: Thread-Wechsel hier
        this.kontostand = this.kontostand + betrag;
    }

    int getProzentualeBarEinzahlungen() {
        if (this.kontostand == 0) {
            return 0;
        }
        return 100 * this.summeBarEinzahlungen / this.kontostand;
    }

    void perUeberweisung(int betrag) {
        this.summeUeberweisungsEinzahlungen = this.summeUeberweisungsEinzahlungen + betrag;
        this.kontostand = this.kontostand + betrag;
    }

    int getKontostand() {
        return this.kontostand;
    }

}

class Konto implements Runnable{
    KontoSL sl;
    private int betrag;

    public Konto(KontoSL sl, int betrag) {
        this.sl = sl;
        this.betrag = betrag;
    }

    @Override
    public void run() {
        int kontostand = 0;
        kontostand += betrag;
        sl.barEinzahlen(kontostand);
    }

    public static void main(String[] args) throws InterruptedException {
        KontoSL sl = new KontoSL();

        Thread thread = new Thread(new Konto(sl, 15));
        Thread thread1 = new Thread(new Konto(sl, 25));

        thread.start();
        thread1.start();
        thread.join();
        thread1.join();

        System.out.println(sl.getKontostand());
    }
}

Moin,

kann jemand mich bitte aufklären, warum meine Code funktioniert?
Result ist immer 40, was korrekt ist.

Normalerweise ohne Semaphore oder Synchronisation sollte richtiges Ergebnis nicht rauskommen. Was mache ich hier falsch?

 

[fhoffmann]

Du machst nichts falsch; der Fehler tritt nur in ganz seltenen Fällen auf:

this.kontostand = this.kontostand + betrag;

Nur wenn im einen Thread this.kontostand gelesen wir, dann zum anderen Thread gewechselt wird, dort this.kontostand geändert wird, und danach wieder vom ersten Thread this.kontostand geschrieben wird, kann ein Fehler auftreten.
In deinem Fall wird das kaum passieren. Bei einer Bank, die tausende von Kontobewegungen am Tag hat, kann dies allerdings hin und wieder auftreten - und wäre sehr peinlich.

 

[KonradN]

Das Ergebnis kann falsch sein. Man kann nicht vorher sagen, wann ein Thread Wechsel statt findet und wann nicht.

Bei Dir ist es so, dass du extrem wenig machst. Der erste Thread ist schon fertig, ehe der zweite wirklich gestartet werden kann. Und der Zeitpunkt, bei dem ein Threadwechsels zu Problemen führen würde, ist sehr klein.

Um da etwas zu forcieren, könntest Du einfach in dem Thread mehrere Einzahlungen machen oder einfach die Zeitspanne sehr groß machen, in der das Problem auftritt:

    void barEinzahlen(int betrag) {
        this.summeBarEinzahlungen = this.summeBarEinzahlungen + betrag;
        try {
            Thread.sleep(1000);
        } catch (Exception e) {}
        this.kontostand = this.kontostand + betrag;
    }

 

[Adriano10]

Ich danke euch, jetzt ist mir alles klar geworden. Vielen Dank

 

[LimDul]

Das macht übrigens Threading-Probleme so unglaublich schwer zu analysieren und zu finden. Aus folgenden Gründen

Sie treten sehr selten auf
Das heißt sie schaffen es selten in direkt in den Fokus. Ein Fehler der nur sporadisch auftritt wird gerne mal mit "naja, lässt sich nicht reproduzieren" geschlossen. Da braucht es schon engagierte Entwickler und technisch versierte Test-Manager / Projektleitung die versteht das ein Fehler, den man nicht versteht potentiell eine tickende Zeitbombe sein kann.

Sie sind meist nicht reproduzierbar
Einen Fehler, den man nicht reproduzieren kann, kann man extrem schwer analysieren. Das einzige, was man machen kann, ist sich den Code ansehen und überlegen warum er sowas getan hat. Und der ist leider selten so gekapselt und simpel wie hier

Die Ursache ist oft ganz woanders/nicht in der Methode sichtbar
Meist schaut man sich den Code an und stellt fest, dass der eigentlich korrekt ist. Die Ursache ist eine parallele Ausführung - die aber oft technisch beliebig weit vom eigentlich Fach-Code sein kann. Das kann sinnbildlich am anderen Ende der Anwendung sein, dass da Threads gestartet werden oder es sind einfach Threads vom Framework. Sprich, man hat in der Regel am Code nie einen Marker "Wird Multi-Threaded ausgeführt".

Analyse verändert das Verhalten
Multi-Threading Bugs sind Timing Probleme. Wie man hier im Thread schön sieht, treten die nicht immer auf. Wenn ich mit Debugger rangehe verändere ich das Timing der Anwendung extrem. Das heißt, viele Threading Probleme tauchen nie auf, wenn ich mit dem Debugger mir das Verhalten ansehe. Mit etwas Glück kann man mit Logging / System.out.println was erreichen - aber selbst das kann das Timing Verhalten verändern.