I have a class that is similar to this:
public class ExpensiveCalculation {
private Executor threadExecutor = ...
private Object lock = new Object();
private Object data = null;
public Object getData() {
synchronized(lock) {
return data;
}
}
pulic void calculate() {
executor.execute(() -> internalCalculation());
}
private void internalCalculation() {
synchronized(lock) {
// do some long running calculation that in the end updates data
data = new Object();
}
}
}
This class makes some expensive (timewise) calculations and acquires a lock. While the lock is hold no one can retrieve the data that will be updated by the calculation, so in effect they have to wait for the calculation to finish. The actual calculation is done in a separate thread. If I have the following code:
ExpensiveCalculation calculation = ...
calculation.calculate();
Object data = calculation.getData();
The call to retrieve the data is blocked until the calculation is done. What exactly does waiting at this point mean?
- Is it a busy waiting
- Does the waiting thread yield, so other threads (like the one doing the computation) can proceed.
- Does the waiting thread go to sleep?
- Is wait/notify invoked behind the scene?
I am aware that for this example I could use a Callable and Future, but that is beside the point. Is there a way to improve such code, to ensure no time resources are wasted (like unnecessary thread switches)?