Java разделяет переменную между двумя потоками

Question

У меня есть два потока. Один вызывает метод обновления класса, который изменяет переменную. Другой вызывает метод обновления класса, который читает переменную. Только один поток пишет и один (или более) поток читает эту переменную. Что мне нужно делать с точки зрения параллелизма, поскольку я новичок в многопоточности?

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... 
    } 
} 

Спасибо,

Answer 1

Если есть одна и только одна нить, которая записывается в variable, вы можете сойти с рук volatile. В противном случае см. Ответ с AtomicInteger.

Только volatile будет работать только в одном потоке записи, потому что есть только одна нитка для записи, поэтому она всегда имеет правильное значение variable.

Answer 2

не только должны быть variablevolatile, но вы также хотите, чтобы защитить вашу update функцию с some sort of synchronization так ++variable не атомный вызов. Это, в конце концов, просто синтаксический сахар для

variable = variable + 1; 

, который не является атомарным.

Вы также должны обернуть любые вызовы, которые читают переменную в некотором виде lock.

В качестве альтернативы используйте AtomicInteger. Это было сделано для такого рода вещей (только для целочисленных операций).

public class A 
{ 
    // initially had said volatile wouldn't affect this variable because 
    // it is not a primitive, but see correction in comments 
    public final AtomicInteger variable; // see comments on this issue of why final 
    public void update() 
    { 
     // Called by one thread constantly 
     variable.getAndIncrement(); // atomically adds one 
    } 
    public int retrieveValue() 
    { 
     return variable.get(); // gets the current int value safely 
    } 
} 

public class B 
{ 
    public A a; 
    public void update() 
    { 
     // Called by another thread constantly 
     int v = a.retrieveValue(); 
     // Do algorithm with v... 
    } 
} 

Для более сложных алгоритмов, как предполагает ваше недавнее изменение, используйте синхронизацию или блокировки.

Answer 3

В этом случае я бы использовал AtomicInteger, однако обобщенный ответ заключается в том, что доступ к переменной должен быть защищен синхронизированным блоком или с использованием другой части пакета java.util.concurrent.

Несколько примеров:

Использование синхронизации

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); 
     } 
    } 
} 

Использование java.util.concurrent

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

Использование AtomicInteger или synchronize доступ к безопасным.