Erro com wait() - Thread

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class SharedBufferMain
{
	public static void main(String[] args)
	{
		ExecutorService executorService = Executors.newCachedThreadPool();
		
		SharedBuffer sharedBuffer = new SharedBuffer();
		
		FutureTask<Integer> futureTask1 = new FutureTask<Integer>(new Produtor(sharedBuffer));
		FutureTask<Integer> futureTask2 = new FutureTask<Integer>(new Consumidor(sharedBuffer));
		
		executorService.execute(futureTask1);
		executorService.execute(futureTask2);
		
		executorService.shutdown();
	}
}

import java.util.Random;
import java.util.concurrent.Callable;

public class Produtor implements Callable<Integer> 
{
	SharedBuffer sharedBuffer;
	private static Random r = new Random();
	
	public Produtor(SharedBuffer sharedBuffer)
	{
		this.sharedBuffer = sharedBuffer;
	}
	
	public Integer call() throws Exception 
	{
		System.out.printf("%-40s%s\t\t%s\n%-40s%s\n\n", "Posição", "Vetor", "Valor",
				"---------", "------\t\t-------");
		
		for(int posicao = 0; posicao < 100; posicao++ )
		{
			sharedBuffer.setValor(posicao, r.nextInt(100));
		}		
		
		return 1;
	}
}

import java.util.concurrent.Callable;

public class Consumidor implements Callable<Integer>
{	
	SharedBuffer sharedBuffer;
	
	public Consumidor(SharedBuffer sharedbuffer)
	{
		this.sharedBuffer = sharedBuffer;
	}
	
	public Integer call() throws Exception 
	{
		for(int posicao = 0; posicao < 100; posicao ++)
		{
			sharedBuffer.getValor(posicao);
		}
		
		return null;
	}
}

public interface ProdutorConsumidor 
{
	public void setValor(int posicao, int valor);
	public int getValor(int posicao);
}

public class SharedBuffer implements ProdutorConsumidor 
{	
	public static final int tamanhoBuffer = 10;
	public static int buffer [] = new int[tamanhoBuffer];
	public boolean turn;
	public int valor;
	
	public int getValor(int posicao)
	{
		synchronized(buffer)
		{		
			while(!turn)
			{
				try
				{
					buffer.wait();
				}
				
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}	
			}

			valor = buffer[posicao%tamanhoBuffer];
			turn = false;
			buffer.notify();
			
			return valor;
		}
	}
	
	public void setValor(int posicao, int valor)
	{
		synchronized(buffer) 
		{
			while(turn)
			{
				try
				{
					buffer.wait();
				}
				
				catch(InterruptedException e)
				{
					e.printStackTrace();
				}
			}
			
			buffer[posicao%tamanhoBuffer] = valor;
			turn = true;
			buffer.notify();
			
			//System.out.printf("\n%s %d%d\n%s\n", posicao, posicao%tamanhoBuffer, valor);
			System.out.println(posicao+"                                         "+
					posicao%tamanhoBuffer+"               "+valor);
		}
	}
}

int[](Object).wait() line: 485 [local variables unavailable]
SharedBuffer.setValor(int, int) line: 16	
Produtor.call() line: 21
Produtor.call() line: 1	
FutureTask$Sync.innerRun() line: not available [local variables unavailable]	
FutureTask<V>.run() line: not available [local variables unavailable]	
ThreadPoolExecutor$Worker.runTask(Runnable) line: not available	
ThreadPoolExecutor$Worker.run() line: not available [local variables unavailable]	
Thread.run() line: not available [local variables unavailable]