Gibt es einen alternativen/besseren Weg, um diese einfache Logik in Java zu machen?

Question

Ich habe eine Methode, sagen wir method1(), das dauert eine Weile zu laufen. Wenn während der Ausführung ein anderer Aufruf von method1() erfolgt, sollte dieser ignoriert werden. Ich habe ungefähr so ​​etwas wie dieses

boolean mFlag = false; 

    void method1() 
    { 
     if(!mFlag) 
     { 
      mFlag=true; 

      // do Stuff 

      mFlag=false; 
     } 
    } 

Dies funktioniert. Aber ich habe mich gefragt, ob es einen besseren Weg gibt, dies zu tun, möglichst ohne Flaggen.

Answer 1

Ja, sollten Sie wirklich etwas von java.util.concurrent.locks verwenden werden Ihr Beispiel recht ist nicht ganz korrekt, muss die boolean volatil sein .

Bearbeitet, um das Überspringen der Ausführung bei Wiedereintritt zu behandeln, wie in Ihrem Kommentar angegeben. Leider gibt es nicht wirklich eine gute Möglichkeit, das mit der eingebauten Bibliothek zu tun, da es ein etwas seltsamer Anwendungsfall ist, aber ich denke immer noch, dass die Verwendung der eingebauten Bibliothek eine bessere Option ist.

Answer 2

Vielleicht sollten Sie synchronisierte Methoden verwenden

http://download.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html

Answer 3

Sie versuchen, sich vor dem Wiedereintritt von demselben Thread oder mehreren Threads zu schützen, die gleichzeitig zugreifen.

Unter der Annahme eines Multi-Thread-Zugriffs ist der Lichtansatz java.util.concurrent.atomic zu verwenden. Keine Notwendigkeit für etwas, das so schwer ist wie ein Schloss (vorausgesetzt, es gibt keine weiteren Anforderungen).

no-Reentry aus der gleichen Methode Unter der Annahme:

private final AtomicBoolean inMethod = new AtomicBoolean(); 

void method1() { 
    if (inMethod.compareAndSet(true, false)) { // Alternatively getAndSet 
     try { 
      // do Stuff 
     } finally { 
      inMethod.set(false); // Need to cover exception case! 
     } 
    } 
} 

Wenn Sie Reentry im selben Thread zulassen wollen, dann wird es chaotisch genug Schlösser zu verwenden:

private final AtomicReference<Thread> inMethod = new AtomicReference<Thread>(); 

void method1() { 
    final Thread current = Thread.currentThread(); 
    final Thread old = inMethod.get(); 
    if (
     old == current || // We already have it. 
     inMethod.compareAndSet(null, current) // Acquired it. 
    ) { 
     try { 
      // do Stuff 
     } finally { 
      inMethod.set(old); // Could optimise for no change. 
     } 
    } 
} 

könnte die Verwendung Execute Around Idiom dafür.