Question

This isn’t homework for me, it’s a task given to students from some university. I’m interested in the solution out of personal interest.

The task is to create a class (Calc) which holds an integer. The two methods add and mul should add to or multiply this integer.

Two threads are set-up simultaneously. One thread should call c.add(3) ten times, the other one should call c.mul(3) ten times (on the same Calc-object of course).

The Calc class should make sure that the operations are done alternatingly ( add, mul, add, mul, add, mul, ..).

I haven’t worked with concurrency related problems a lot – even less with Java. I’ve come up with the following implementation for Calc:

class Calc{

    private int sum = 0;
    //Is volatile actually needed? Or is bool atomic by default? Or it's read operation, at least.
    private volatile bool b = true;

    public void add(int i){
        while(!b){}
        synchronized(this){
                sum += i;
            b = true;   
        }
    }

    public void mul(int i){
        while(b){}
        synchronized(this){
            sum *= i;
            b = false;  
        }
    }

}

I’d like to know if I’m on the right track here. And there’s surely a more elegant way to the while(b) part.
I’d like to hear your guys’ thoughts.

PS: The methods’ signature mustn’t be changed. Apart from that I’m not restricted.

Answer 1

volatile is needed otherwise the optimizer might optimize the loop to if(b)while(true){}

but you can do this with wait and notify

public void add(int i){

    synchronized(this){
        while(!b){try{wait();}catch(InterruptedException e){}}//swallowing is not recommended log or reset the flag
            sum += i;
        b = true;   
        notify();
    }
}

public void mul(int i){
    synchronized(this){
        while(b){try{wait();}catch(InterruptedException e){}}
        sum *= i;
        b = false;  
        notify();
    }
}

however in this case (b checked inside the sync block) volatile is not needed