Java: Synchronisierung von Threads

[anve]

Hallo zusammen!

Ich möchte zwei Threads synchronisieren. Der eine Thread erhöht eine Variable, der zweite Thread dekrementiert sie. Ich mache das ganze ja mit "synchronized" Threadsicher. Aber irgendwie klappts nicht so ganz. Der zweite Thread wird gestartet obwohl der erste noch rennt.

Hier mal der Code:

class increase extends Thread{
    public synchronized void run(){
        System.out.println("Beginn increased 1");
        Global.number++;
        System.out.println(Global.number);
        try {
            increase.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("End increased");
    }
}
class decrease extends Thread{
    public synchronized void run(){
        System.out.println("Beginn decreased 1");
        Global.number--;
        System.out.println(Global.number);
        try {
            decrease.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("End decreased");
    }
}

public class test {

    /**
     * @param args
     */
    
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        increase thread_one = new increase();
        decrease thread_two = new decrease();
        
        System.out.println("Startwert: " + Global.number);
        thread_one.start();
        thread_two.start();
        System.out.println("Endwert: " + Global.number);
    }

}

Und hier meine globale Variable:

public class Global{
    public static int number=1;
}

Dabei werden die Threads nach dem ich am Ender der Main bin erst gestartet!? Hier die Ausgabe von mir:

Startwert: 1
Endwert: 1
Beginn increased 1
2
Beginn decreased 1
1
End increased
End decreased

Warum funktioniert die synchronized Methode nicht? Mir wurde gesagt, dass diese nur auf Objekte funktioniert. Aber ich hab kA wie das gehen sollte. Gibt es ein paar Java-Spezialisten unter euch?

LG
anve

[jak]

Wie du schon gesagt hast funktioniert synchronized nur auf Objekte, nicht auf primitive Typen (int, float, boolean, ...).

Das hier:

 public synchronized void run(){

heißt das die Methode run() nur von einem (1) anderen Thread aufgerufen werden kann. Eigentlich heißt es sogar noch ein bischen mehr. synchronized in einer Methodensignatur (also z.B. public synchronized void foo(){...}) bedeutet das ein Lock auf this (das aktuelle Objekt) gesetzt wird. D.h. wenn es mehrere synchronized methoden gibt kann im selben Objekt nur eine von beiden gleichzeitig laufen.

Du synchronisierst run(), eigentlich willst du aber der inkrement/dekrement synchronisieren.
Das würde in etwa so funktionieren:

public class Global{
    private static int number=1;
    public synchronized void increment(){
        number++;
    }
    public synchronized void decrement(){
        number--;
    }
}

jak