In che modo il metodo attende il rilascio del blocco?

Question

Ho una classe che è simile a questo:

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

Questa classe rende alcuni costosi calcoli (TimeWise) ed acquisisce una serratura. Mentre il blocco è attivo, nessuno può recuperare i dati che verranno aggiornati dal calcolo, quindi in effetti devono attendere il completamento del calcolo. Il calcolo effettivo viene eseguito in un thread separato. Se ho il seguente codice:

ExpensiveCalculation calculation = ... 
calculation.calculate(); 
Object data = calculation.getData(); 

La chiamata per recuperare i dati è bloccato fino a quando il calcolo è fatto. Cosa significa esattamente aspettare in questo punto?

• E 'un occupato in attesa
• Ha la resa thread in attesa, così altri thread (come quella di fare il calcolo) può procedere.
• Il thread in attesa si addormenta?
• È attesa/notifica invocata dietro la scena?

Sono consapevole che per questo esempio potrei usare un Callable e Future, ma che è questo il punto. C'è un modo per migliorare tale codice, per garantire che non vengano sprecate risorse di tempo (come interruttori di thread non necessari)?

Answer 1

E 'un'attesa

occupato No.

Fa la resa thread in attesa, in modo che altri fili (come quello di fare il calcolo) può procedere.

No, blocca, in modo che altri thread possano essere eseguiti.

Il thread di attesa si addormenta?

È bloccato.

È attesa/notifica invocata dietro la scena?

No.