So sperren Sie eine Methode für die ganze Klasse mit synchronisiert?

Synchronisieren auf ein bestimmtes Objekt, entweder einige bestimmten statisches lock-Objekt, oder das Objekt der Klasse (was passiert, wenn statische Methoden deklariert sind, werden synchronisiert):

class X {
    private static final Object lock = new Object();
    public void oneAtATime() {
        synchronized (lock) {
            //Do stuff
        }
    }
}
class Y {
    public void oneAtATime() {
        synchronized (Y.class) {
            //Do stuff
        }
    }
}

Jede Variante hat seine eigenen vor-und Nachteile; verriegeln auf die Klasse erlaubt es anderen code, außerhalb der Klasse zu verwenden, die gleiche Sperre für seine eigenen Gründe (die es erlaubt zu orchestrieren mehr high-level-Synchronisation als das, was Sie bieten), während die static final Object lock Ansatz ermöglicht es Ihnen verbietet, indem Sie die lock-Feld "privat" (was es leichter macht, auf Grund über das Sperr-und vermeiden Sie Ihr code von Deadlocks, weil jemand anderes schrieb schlechten code).

Könnte man natürlich auch einige Synchronisations-Mechanismus von java.util.gleichzeitige, wie explizite Locks, die mehr Kontrolle über die Verriegelung (und die ReentrantLock führt momentan ein wenig besser als implizite sperren unter hohem Streit -).

Edit: Beachten Sie, dass statische/Globale sperren sind nicht ein guter Weg zu gehen - es bedeutet, dass jede Instanz der Klasse, die jemals geschaffen werden, im wesentlichen gebunden werden, um jede andere Instanz (die, abgesehen davon macht es schwieriger, um zu testen, oder Lesen Sie den code, können ernsthaft Schaden Skalierbarkeit). Ich nehme an, Sie tun dies, um zu synchronisieren, die irgendeine Art von globaler Zustand? In diesem Fall würde ich prüfen, - Verpackung, die globalen/statischen Zustand in einer Klasse statt, und implementieren Synchronisation per-instance statt Global.

Sondern so etwas wie dieses:

class Z {
    private static int state;
    public void oneAtATime(){
        synchronized (Z.class) {
            state++;
        }
    }
}

Machen Sie es wie diese:

class State {
    private int value;
    public synchronized void mutate(){ value++; }
}
class Z {
    private final State state;
    public Z(State state){
        this.state = state;
    }
    public void oneAtATime(){
        state.mutate();
    }
}
//Usage:
State s1 = new State(), s2 = new State();
Z foo = new Z(s1);
Z bar = new Z(s1);
Z frob = new Z(s2);
Z quux = new Z(s2);

Nun foo und bar sind immer noch aneinander gefesselt, aber Sie können selbständig arbeiten frob und quux.

Könnte man eine statische Mutex innen diese Methode. Also der gleichzeitigen thread wird blockiert innerhalb der Methode, während eine andere läuft, ist es egal, welches Objekt von der Klasse zu der er gehört. Ich glaube nicht, dass es irgendwelche besonderen einzelnes keyword zu produzieren, die gleiche Wirkung wie synchronized.

Ist es eine eher aggressive Synchronisation, ich würde es vermeiden, so viel wie möglich.

Beide threads verwenden müssen, diese Konstruktion

public void someMethod() {
  synchronized(ClassThatShouldBeProtected.class) {
    someSynchronizedCode();
  }
}

Dieser Ansatz profitiert von der Tatsache, dass die Klasse selbst ist ein Objekt und hat daher einen monitor. Dann brauchen Sie nicht jede künstliche statische Instanz.

Sollte dies funktionieren:

public class MyClass {
  void synchronizedMethod() {
    synchronized (MyClass.class) {
       //synchronized on static level
    }
  }
}

Die 'missuses' der Klasse runtime-Darstellung für die Verriegelung. Dies ist möglich, da jedes Objekt kann verwendet werden, als eine mutex in Java.