Error Monitor Thread

package acordandoThreadExterna;

public class ProdutorTrabalho {

	Trabalhador w;
	int valor;
	int id = 1;

	public static void main(String[] args){
		ProdutorTrabalho prod = new ProdutorTrabalho();
		prod.inicializa();
	}
	public void inicializa() {
		for (int i = 0; i < 5; i++) {
			this.w = new Trabalhador(this.id++, this);
			this.w.start();
			this.produz();
		}
	}

	public void produz() {
		for (int i = 0; i < 10; i++) {
			valor = 5 + (int) (Math.random() * 40);
			this.w.recebe(valor);
		}
	}

	public void recebeStatus(int t, int status) {
		System.out.println("Recebi Status do Trabalhador: " + t
				+ " com tamanho da fila: " + status);
	}

}

package acordandoThreadExterna;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Trabalhador extends Thread {

	ProdutorTrabalho ger;
	UpStatus control;
	BlockingQueue<Integer> work;
	int valor;
	int id;

	public Trabalhador(int id, ProdutorTrabalho ger) {
		this.id = id;
		this.ger = ger;
		this.control = new UpStatus(this);
		this.control.start();
		this.work = new LinkedBlockingQueue<Integer>();
	}

	public void run() {
		try {
			this.valor = this.work.take();
			this.fibo(valor);
			this.atualiza();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void atualiza() {
		this.ger.recebeStatus(this.getID(), this.work.size());
	}

	public void recebe(int valor) {
		try {
			this.work.put(valor);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public int fibo(int n) {
		if (n <= 1)
			return n;
		return fibo(n - 1) + fibo(n - 2);
	}
	
	public void setID(int id) {
		this.id = id;
	}
	
	public int getID() {
		return this.id;
	}
}

package acordandoThreadExterna;

public class UpStatus extends Thread{
	
	Trabalhador worker;
	UpStatus (Trabalhador worker) {
		this.worker = worker;
	}
	public void run() {
		while (true) {
			this.worker.atualiza();			
			try {
				wait(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

Então vamos ver se eu entendi:

a) A classe produtora deve produzir algo para o consumidor fazer a cada 5 segundos;

b) Se o consumidor informar que está ocioso, então um trabalho deve ser criado imediatamente;

import java.util.Random;

public class ProdutorTrabalho {
	private Trabalhador trabalhador;
	private Random random = new Random();

	public ProdutorTrabalho(Trabalhador trabalhador) {
		this.trabalhador = trabalhador;

		// Disparamos a thread produtora
		Thread produtor = new Thread(new Runnable() {
			public void run() {
				produzirTrabalho();
			}
		});
		produtor.setName("Produtor");
		produtor.start();
	}

	/**
	 * Método do produtor que recebe um status enviado pelo trabalhador. Isso faz com que o produtor gere trabalho
	 * imediatamente caso a fila seja < 3.
	 */
	public synchronized void receberStatus(int tamFila) {
		System.out.print("Requisição de trabalho");
		if (tamFila < 3) {
			System.out.println(" aceita.");
			// Esse notify irá acordar o wait do método produzTrabalho.
			notifyAll();
		} else
			System.out.println("negada. Já há muito trabalho na fila.");
	}

	/**
	 * Gera um novo trabalho a cada 5 segundos, ou quando uma requisição for feita ao receber status.
	 */
	private synchronized void produzirTrabalho() {
		try {
			while (!Thread.interrupted()) {
				int nr = random.nextInt(40) + 10;
				System.out.println("Trabalho produzido: " + nr);
				trabalhador.receberTrabalho(nr);
				// Aguarda 5s. O notifyAll() também libera o wait.
				wait(5000);
			}
		} catch (InterruptedException e) {
		}
	}
}

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class Trabalhador {
	private BlockingDeque<Integer> trabalhos = new LinkedBlockingDeque<Integer>();
	private ProdutorTrabalho produtor;

	public void definirProdutor(ProdutorTrabalho produtor) {
		if (this.produtor != null)
			return;

		this.produtor = produtor;
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				trabalhar();
			}
		});
		thread.setName("Consumidor");
		thread.start();
	}

	/** Simplesmente insere um trabalho na fila.
	 * O método offer avisa o método take(), que desbloqueia a thread. */
	public void receberTrabalho(int trabalho) {
		trabalhos.offer(trabalho);
	}

	public void trabalhar() {
		try {
			System.out.println("Aguardando trabalho.");
			while (true) {
				// Aguardamos até que haja trabalho. 
				//O take() bloqueia a thread caso a fila esteja vazia.
				Integer trabalho = trabalhos.take();
				//Trabalhamos
				trabalhar(trabalho);
				//Avisamos o produtor que concluímos.
				produtor.receberStatus(trabalhos.size());
			}
		} catch (InterruptedException e) {
		}
	}

	private void trabalhar(Integer trabalho) {
		System.out.println("Trabalhando no Fibonacci(" + trabalho + ")...");
		System.out.println("Resultado: Fibonacci(" + trabalho + ") = "
				+ fibo(trabalho));
	}

	private long fibo(int n) {
		if (n <= 1)
			return n;
		return fibo(n - 1) + fibo(n - 2);
	}
}

public class Main {
	public static void main(String[] args) {
		Trabalhador trabalhador = new Trabalhador();
		ProdutorTrabalho produtor = new ProdutorTrabalho(trabalhador);
		trabalhador.definirProdutor(produtor);
	}
}