MultiThreading

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class SynchronizedBuffer implements Buffer {
    
    private Lock accessLock = new ReentrantLock();
    
    private Condition canWrite = accessLock.newCondition();
    private Condition canRead = accessLock.newCondition();
    
    
    private int buffer = -1;
    private boolean occupied = false;
    
    
    public void set(int value){
        
        accessLock.lock();
        
        try{
            
            while(occupied){
                System.out.println("Producer tries to write");
                displayState("Buffer full. Producer waits");
                canWrite.await();
            }
            
            buffer = value;
            
            displayState("Producer writes: "+ buffer);
            
            canRead.signal();
        }catch(InterruptedException exception){
            exception.printStackTrace();
        }
        finally{
            accessLock.unlock();
        }
    }
    
    public int get(){
        
        int readValue = 0;
        accessLock.lock();
        
        try{
            while(!occupied){
                System.out.println("Consumer tries to read");
                displayState("Buffer empty. Consumer waits");
                canRead.await();
            }
            
            occupied = false;
            
            readValue = buffer;
            displayState("Consumers reads: "+ readValue);
            
            canWrite.signal();
        }
        catch(InterruptedException exception){
            exception.printStackTrace();
        }finally{
            accessLock.unlock();
        }
        return readValue;
    }
    
    
    public void displayState(String operation){
        System.out.printf("%-40s%d\t\t%b\n\n", operation, buffer, occupied);
    }

Mas assim, na linha 26   canWrite.await();

e na linha 34 canRead.signal();

canRead e canWrite são variáveis de instância de objeto retornado pelo método accessLock.newCondition(). O método accessLock.newCondition() retorna um objeto do tipo Condition, ok!

Mas Condition é uma interface, logo não tem uma implementação do método. Por polimorfismo ele pode estar executando esse método de alguma classe que implemente Conditions mas qual classe é essa?

Na API está

All Known Implementing Classes:

AbstractQueuedLongSynchronizer.ConditionObject, AbstractQueuedSynchronizer.ConditionObject

Nenhuma eu fiz menção no código…

se await e signal possuem a função  de colocar uma thread para estado de espera e  sinalizar que pode tirar a thread do estado de espera para executável quando esta ganhar a lock, algum código tem que ter para realizar isso…