Java teilen eine Variable zwischen zwei Threads

Question

Ich habe zwei Threads. Man ruft die Aktualisierungsmethode einer Klasse auf, die eine Variable modifiziert. Ein anderes ruft die Update-Methode einer Klasse auf, die die Variable liest. Nur ein Thread schreibt und ein (oder mehrere) Threads lesen diese Variable. Was muss ich in Bezug auf Nebenläufigkeit tun, da ich neu im Multithreading bin?

public class A 
{ 
    public int variable; // Does this need to be volatile? 
     // Not only int, could also be boolean or float. 
    public void update() 
    { 
     // Called by one thread constantly 
     ++variable; 
     // Or some other algorithm 
     variable = complexAlgorithm(); 
    } 
} 

public class B 
{ 
    public A a; 
    public void update() 
    { 
     // Called by another thread constantly 
     // I don't care about missing an update 
     int v = a.variable; 
     // Do algorithm with v... 
    } 
} 

Danke,

Answer 1

Wenn es einen und nur einen Thread gibt, der in variable schreibt, können Sie es schaffen volatile zu machen. Ansonsten siehe die Antwort mit AtomicInteger.

Nur volatile funktioniert bei nur einem Schreib-Thread, da es nur einen Schreib-Thread gibt, so dass es immer den richtigen Wert von variable hat.

Answer 2

sollte variable nicht nur volatile, aber Sie wollen auch mit some sort of synchronization seit ++variable Ihre update Funktion zu schützen, ist nicht ein Atom Anruf. Es ist schließlich nur syntaktischer Zucker für

die nicht atomar ist.

Sie sollten auch alle Anrufe, die Variable in einem lock von irgendeiner Art lesen, umbrechen.

Alternativ können Sie auch AtomicInteger verwenden. Es wurde für diese Art von Sache gemacht (für nur ganzzahlige Operationen).

Für die komplexeren Algorithmen, wie Ihre kürzliche Bearbeitung annimmt, verwenden Sie Synchronisation oder Sperren.

Answer 3

In diesem Fall würde ich eine AtomicInteger verwenden, aber die generalisierte Antwort ist, dass der Zugriff auf die Variable durch einen synchronisierten Block oder durch die Verwendung eines anderen Teils des java.util.concurrent-Pakets geschützt werden sollte.

Ein paar Beispiele:

public class A { 
    public final Object variable; 
    public void update() { 
     synchronized(variable) { 
      variable.complexAlgorithm(); 
     } 
    } 
} 

public class B { 
    public A a; 
    public void update() { 
     sychronized(a.variable) { 
      consume(a.variable); 
     } 
    } 
} 

synchronisiert Verwenden java.util.concurrent Mit

public class A { 
    public final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); 
    public final Object variable; 
    public void update() { 
     lock.writeLock().lock(); 
     try { 
      variable.complexAlgorithm(); 
     } finally { 
      lock.writeLock().unlock(); 
     } 
    } 
} 

public class B { 
    public A a; 
    public void update() { 
     a.lock.readLock().lock(); 
     try { 
      consume(a.variable); 
     } finally { 
      a.lock.readLock().unlock(); 
     } 
    } 
} 

Answer 4

Verwenden AtomicInteger oder synchronize den Zugriff sicher zu sein.