Der Schnellste Weg für Java zu schreiben, Mutexe?

Mutexe sind sehr verbreitet in vielen Programmiersprachen, wie z.B. C/C++. Ich vermisse Sie in Java.

Nicht sicher, ob ich dir Folgen (vor allem, weil du gibst die Antwort in deiner Frage).

public class SomeClass {
    private final Object mutex = new Object();

    public void someMethodThatNeedsAMutex() {
        synchronized(mutex) {
            //here you hold the mutex
        }
    }
}

Alternativ können Sie einfach die gesamte Methode synchronisiert, die gleichwertig ist mit this als das mutex-Objekt:

public class SomeClass {

    public synchronized void someMethodThatNeedsAMutex() {
        //here you hold the mutex
    }
}

Was ist der Schnellste (beste Laufzeit) Weg?

Erwerb /loslassen ein monitor ist nicht dabei, um eine erhebliche performance-Problem per se (Sie können Lesen in diesem blog-post, um zu sehen, eine Analyse der Auswirkungen). Aber wenn Sie viele threads kämpfen für das Schloss, es wird zu Konflikten und beeinträchtigen die Leistung.

In diesem Fall die beste Strategie ist nicht zu verwenden, Mutexe durch die Verwendung von "lock-free" - algorithmen wenn Sie sind meist die Daten zu Lesen (wie bereits von Marko in den Kommentaren, lock-frei verwendet CAS-Operationen, welche möglicherweise beinhalten, wiederholt schreibt, viele Male, wenn Sie viel schreiben-threads, die schließlich führt zu schlechter Leistung), oder noch besser, durch die Vermeidung zu teilen, zu viel Zeug auf mehrere threads.

InformationsquelleAutor assylias

In Java jedes Objekt kann verwendet werden als Mutex.

Diese Objekte sind arttypisch mit dem Namen "lock" oder "mutex".

Können Sie erstellen das Objekt für sich, das ist die bevorzugte Variante, da es verhindert den externen Zugriff auf das lock:

  //usually a field in the class
    private Object mutex = new Object();

    //later in methods
    synchronized(mutex) {
      //mutual exclusive section for all that uses synchronized
      //ob this  mutex object

    }

Schneller ist zu vermeiden, den mutex, indem wir denken, was passiert, wenn ein anderer thread liest eine nicht den tatsächlichen Wert. In einigen Situationen würde die Produktion falscher Rechenergebnisse, die in anderen Ergebnisse nur in einer minimalen Verzögerung. (aber schneller als mit der Synchronisierung)

Ausführliche Erklärung im Buch

Java Concurreny in der Praxis

.

InformationsquelleAutor AlexWien

Können Sie führen Sie die micro-benchmarks von jeder Variante, wie Atomare, synchronisierte, gesperrt. Wie andere haben darauf hingewiesen, es hängt viel an der Maschine und die Anzahl der verwendeten threads an. In meiner eigenen Experimente, die Inkrementierung von langen Ganzzahlen, fand ich, dass mit nur einem thread auf einem Xeon W3520, synchronisiert gewinnt über atomic: Atomic/Sync/Lock: 8.4/6.2/21.8 in nanos pro Inkrement-operation.
Dies ist natürlich eine Grenze, da gibt es nie Streit. Natürlich, in diesem Fall können wir auch einen Blick auf nicht synchronisierte single-threads lange Schrittweite, die sechs mal schneller als Atom.

Mit 4 threads, die ich bekommen 21.8/40.2/57.3. Beachten Sie, dass diese sind alle Schritten quer durch alle threads, so dass wir tatsächlich sehen, eine Verlangsamung. Es wird ein bisschen besser für Schlösser mit 64 threads: 22.2/45.1/45.9.

Ein weiterer test auf eine 4-Weg/64T-Maschine mit Xeon E7-4820-Renditen für 1 thread: 9.1/7.8/29.1, 4 threads: 18.2/29.1/55.2 und 64 Threads: 53.7/402/420.

Eine weitere Datenpunkt, dieses mal ein dual Xeon X5560, 1T: 6.6/5.8/17.8, 4T: 29.7/81.5/121, 64T: 31.2/73.4/71.6.

Also, auf einer multi-sockel-Maschine, es ist ein schwerer cache-Kohärenz-Steuer.

InformationsquelleAutor Ralf H