Exercicio com Thread (Duvidas)

/*
 1) Desenvolva um aplicativo Java que crie duas threads que compartilham o mesmo objeto
* (espaço na memória). A primeira thread deve gravar a cada 2 segundos nesse objeto um
* número aleatório entre 1 e 3000. A segunda thread deve ler esse valor armazenado no
* objeto compartilhado e entrar no estado de espera cronometrado, no qual o tempo de
* espera deverá ser o valor lido em milisegundos.
*
* Todos os valores escritos pela primeira thread deve ser lidos pela segunda, portanto,
* caso a segunda thread ainda esteja no estado de espera, a primeira não pode escrever
* nenhum valor no objeto compartilhado.
*
* Esse processo de escrita e leitura deve ocorrer 5 vezes cada, ou seja, a primeira
* thread deve escrever 5 vezes um número no objeto compartilhado e a segunda thread
* deve ler esses 5 valores.
 */

Abaixo segue meu código, gostaria de possiveis soluções, pois meu código não está rodando e como sou novo no java não sei onde estou errando, já pesquisei muito antes de posta-lo aqui, desde já agradeço....

package thread;


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

        public class Tarefa04 implements Buffer
        {
           

           // Bloqueio para controlar sincronização com esse buffer
           private Lock bloquearAcesso = new ReentrantLock();

           // condições para controlar leitura e gravação
           private Condition canGrava = bloquearAcesso.newCondition();
           private Condition canLer = bloquearAcesso.newCondition();
           private static Random gerador= new Random();
           private int objeto = -1; // compartilhado pelas threads producer e consumer
           private boolean ocupada = false; // se o buffer estiver ocupado
           int i;
           // coloca o valor int no buffer
            
           public  void set( int n )
                   

           {
               for(i=0;i<=5;i+=1)
               bloquearAcesso.lock(); // bloqueia esse objeto

              // envia informações de thread e de buffer para a saída, então espera

              try
              {
                 // enquanto o buffer não estiver vazio, coloca thread no estado de espera
                 while ( ocupada )
                 {
                    System.out.println( "Thread Tentando Escrever." );
                    displayState( "Buffer cheio.Thread Então espera." );
                    canGrava.await(); // espera até que o buffer esteja vazio
                 } // end while

                 objeto = n; // configura novo valor de buffer

                 // indica que a produtora não pode armazenar outro valor
                 // até a consumidora recuperar valor atual de buffer
                 ocupada = true;

                 displayState( "Thread escreve " + objeto );

                 // sinaliza a thread que está esperando para ler a partir do buffer
                 canLer.signal();
              } // fim do try
              catch ( InterruptedException exception )
              {
                 exception.printStackTrace();
              } // fim do catch
          finally
              {
              bloquearAcesso.unlock(); // desbloqueia esse objeto
              } // fim do finally
           } // fim do método set

           // retorna valor do buffer
           public int get()
           {
              int readValue = 0; // inicializa de valor lido a partir do buffer
              bloquearAcesso.lock(); // bloqueia esse objeto
              // envia informações de thread e de buffer para a saída, então espera
              try
              {
                 // enquanto os dados não são lidos, coloca thread em estado de espera
                 while ( !ocupada )
                 {
                    System.out.println( "Thread Tenta ler." );
                    displayState( "Buffer vazio.Thread Espera." );
                    canLer.await(); // espera até o buffer tornar-se cheio
             } // fim do while

                 // indica que a produtora pode armazenar outro valor
                 // porque a consumidora acabou de recuperar o valor do buffer
                 ocupada = false;

                 readValue = objeto; // recupera o valor do buffer
                 displayState( "Thread lê " + readValue );
                 // sinaliza a thread que está esperando o buffer tornar-se vazio
                 Thread.sleep( gerador.nextInt( 2000 ) ); // thread sleep
                 canGrava.signal();
              } // fim do try
              // se a thread na espera tiver sido interrompida, imprime o rastreamento de pilha
              catch ( InterruptedException exception )
              {
                 exception.printStackTrace();
              } // fim do catch
              finally
              {
                  bloquearAcesso.unlock(); // desbloqueia esse objeto
              } // fim do finally

              return readValue;
           } // fim do método get

           // exibe a operação atual e o estado de buffer
           public void displayState( String operation )
           {
              System.out.printf( "%-40s%d\t\t%b\n\n", operation, objeto,
                      ocupada );
       } // fim do método displayState
        } // fim da classe SynchronizedBuffer
--------------------------------------------------------------------------
Em seguida a classe Buffe que criei


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package thread;

		// Fig. 23.6: Buffer.java
		// Interface Buffer especifica métodos chamados por Producer e Consumer.

		public interface Buffer
		{
		   public void set( int n ); // coloca o valor int no Buffer
		   public int get(); // retorna o valor int a partir do Buffer
		} // fim da interface Buffer
--------------------------------------------------------------------------------------------------
Logo mais a classe rad para gerar um numero aleatorio...

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package thread;

import java.util.Random;

/**
 *
 * @author Warley
 */
class rand {

Random rand = new Random();
int n = rand.nextInt(30) + 10;
}