How to make a series of steps atomic in Java?

Question

I have a series of steps that does some operation (a sequence-of-steps) on two class variables (say var1 and var2). This operation has been schedules to run every 250 milliseconds with the help of a ScheduledExecutorService. What I want to do is that whenever I try to refer to the values in var1 and var2 from a separate thread, their state should confer with the atomicity of the sequence-of-steps that I have performed on them. So, let say I have the following code:

mySchedulesExecutor.scheduleAtFixedRate(new Runnable() {
........................
// these are my 'sequence-of-steps'
var1 += 1;
var1 %= 4;
var2 += 25;
........................
}, 0, 250, TimeUnit.MILLISECONDS);

Whenever I want to read the values of var1 and var2 from anywhere else, they should be consistent with the atomicity of the above mentioned sequence-of-steps. What is the best way to achieve this?

Answer 1

I believe that best practise for your situation is to use immutable object, where you store actual values of var1 and var2. Example:

public class Holder {
   private final double var1;
   private final double var2;

//constructor, getters ommitted
}

public class OuterClass {

  private volatile Holder holder = new Holder(0, 0);

  private void calculateNew() {

    //new calculation omitted
    holder = new Holder(newVar1, newVar2);
  }

  public Holder getVars() {
    return holder;
  }
}

With this solution, you dont need to use any ugly synchronized for consistency, so its guaranteed, that client from outside will always get consistence values of var1 a var2.

I believe that this solution is better than using synchronized, because with synchronized, you must use the same lock not just for writing variables but also for reading. So when you are writing new values, no other thread can read original values. As i understood from your original post, this is not the behaviour that you want. You just want the other threads to be able to read values continuously, even the old values, but always consistent values. Thats way its better to use immutable idiom because it will give you better response (other threads dont have to wait every time new value is writing)

Answer 2

Then they should not be accessible as class (that is static, maybe volatile) variables.

One might think of transactions with commit/rollback. But I do not see a need here.

In fact one would need an object with fields var1 and var2 one may get and set atomically. Then one would always have a point-in-time guarantee.

That object might be immutable, any change resulting in a new object, like BigDecimal.

public class Data {
    public final int var1;
    public final int var2;
    public Data(int var1, int var2) {
        this.var1 = var1;
        this.var2 = var2;
    }
}

For many readers, one writer on time tick, one would think of a ReadWriteLock. However an Atomic might do too.

public class Holder {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock r = lock.readLock();
    private final Lock w = lock.writeLock();

    private static Holder instance = new Holder();

    public static Data getData() {
        ...
    }

    public static Data setData() {
    }
}

Answer 3

You can use 'synchronized' keyword (blocked)

class App {
    int var0 = 0;
    int var1 = 0;

    public synchronized void apply(IntUnaryOperator f0, IntUnaryOperator f1) {
        this.var0 = f0.applyAsInt(this.var0);
        this.var1 = f0.applyAsInt(this.var1);
    }

    public synchronized int[] get() {
        return new int[] {var0, var1};
    }
}

or 'Lock' class (blocked)

class App {
    Lock lock = new ReentrantLock();
    int var0 = 0;
    int var1 = 0;

    public void apply(IntUnaryOperator f0, IntUnaryOperator f1) {
        lock.lock();
        try {
            this.var0 = f0.applyAsInt(this.var0);
            this.var1 = f0.applyAsInt(this.var1);
        } finally {lock.unlock();}
    }

    public int[] get() {
        lock.lock();
        try {
            return new int[]{var0, var1};
        } finally {lock.unlock();}
    }
}

or use 'AtomicReference' to immutable data structure (non-blocked)

class App {
    AtomicReference<Data> data = new AtomicReference<>(new Data(0, 0));

    public void apply(IntUnaryOperator f0, IntUnaryOperator f1) {
        while (true) {
            Data oldData = data.get();
            Data newData = new Data(
                    f0.applyAsInt(oldData.var0),
                    f1.applyAsInt(oldData.var1)
            );
            if (data.compareAndSet(oldData, newData)) {
                break;
            }
        }
    }

    public int[] get() {
        Data current = data.get();
        return new int[]{current.var0, current.var1};
    }

    static class Data {
        final int var0;
        final int var1;

        public Data(int var0, int var1) {
            this.var0 = var0;
            this.var1 = var1;
        }
    }
}

or realize something like 'actor model' (non-blocking + with additional Thread) for writing and non-blocking atomic reading

class App {
    AtomicReference<Data> data = new AtomicReference<>(new Data(0, 0));
    BlockingQueue<IntUnaryOperator[]> mutateOperations
            = new LinkedBlockingQueue<>();
    Thread writer;
    {
        this.writer = new Thread(() -> {
            while (true) {
                try {
                    IntUnaryOperator[] mutateOp = mutateOperations.take();
                    Data oldData = data.get();
                    data.set(new Data(
                            mutateOp[0].applyAsInt(oldData.var0),
                            mutateOp[1].applyAsInt(oldData.var1)
                    ));
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        this.writer.start();
    }

    public void apply(IntUnaryOperator f0, IntUnaryOperator f1) {
        mutateOperations.add(new IntUnaryOperator[]{f0, f1});
    }

    public int[] get() {
        Data current = data.get();
        return new int[]{current.var0, current.var1};
    }

    static class Data {
        final int var0, var1;
        public Data(int var0, int var1) {
            this.var0 = var0;
            this.var1 = var1;
        }
    }
}

Answer 4

There is AtomicInteger API in Java SE.