Dúvida com thread e TimerTask

Programação Java
#1

Boa Tarde, gostaria de um help e sugestões para resolução do seguinte problema:
Eu tenho uma tela em swing onde o usuário preenche alguns campos e ao clicar no botão é startado um processo que realiza uma série de cálculos para as filiais da empresa. Como esse processo estava muito lento e fazia muito acesso a banco de dados, eu criei uma classe seguindo o pattern Observer que utiliza uma TimerTask e cria um pool de Threads para executar esse cálculo concorrentemente para cada filial, já que são 160 filiais e não daria para ficar calculando seqüencialmente.
Bom até aí tudo bem, o programa melhorou considerávelmente a performance, porém quando o usuário clica no botão para realizar o cálculo, eu desabilito o botão e todos os campos da tela. Só que eu não estou conseguindo bolar uma maneira para que ao término da execução do cálculo seja enviada uma mensagem ao usuário informando que o processo já foi encerrado.
Abaixo está o código:

[code]import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;

public class Observer
{
private long lastHeartBeat;
private Vector filiais;
private Timer timer;
private Execucao execucao;
private static Observer instance;
private long timeOut;

public synchronized void setLastHeartBeat(long lastHeartBeat)
{
	this.lastHeartBeat = lastHeartBeat;
}

public synchronized long getLastHeartBeat()
{
	return lastHeartBeat;
}

private Observer()
{  
    	timeOut = 600000;
}

public static Observer getInstance()
{
	if (instance == null)
	{
		instance = new Observer();
	}
	return instance;
}


public Execucao getExecucao()
{
	return execucao;
}

public void setExecucao(Execucao execucao)
{
	this.execucao = execucao;
}

public void stopObservation(){
	filiais = null;
}

public void startObservation(Vector filiaisParaCalculo) throws ObserverException
{
	setLastHeartBeat(0);
	filiais = filiaisParaCalculo;
	timer = new Timer();
	TimerTask task = new TimerTask()
	{
		// Thread de observacao de execucao
		// caso a execucao esteja travada, 
		public void run()
		{
			//System.out.println("getLastHeartBeat() = " + getLastHeartBeat());
			//System.out.println("Observer: antes da execucao");
			if (getLastHeartBeat() + timeOut < System.currentTimeMillis())
			{
				System.out.println("[" + new Date() + "] - Iniciando execução.");
				if (execucao == null)
				{
					System.out.println("[" + new Date() + "] - Executando");
					execucao = new Execucao(filiais);
					execucao.start();
				}
				else
				{
					System.out.println("[" + new Date() + "] - Parando execução anterior.");
					execucao.stopExecution();
					System.out.println("[" + new Date() + "] - Reiniciando execução por timeout.");
					if (filiais != null){
						execucao = new Execucao(filiais);
						execucao.start();
					}else{
						timer.cancel();
					}
				}
			}
			else
			{
				// nao deu timeout, mas a execucao já pode ter finalizado, 
				// reniciar execucao neste caso
				if (execucao != null)
				{
					if (execucao.isTerminated())
					{
						System.out.println("[" + new Date() + "] - Execução terminada, reiniciando.");
						execucao = new Execucao(filiais);
						execucao.start();
					}
				}
			}
			//System.out.println("Observer: depois da execucao");
		}
	};
	timer.schedule(task,new java.util.Date(), 10000);
	if (filiais == null){
		throw new ObserverException("Erro");
	}
}

}

[/code]
A classe Execucao, cria um pool de Threads que chama a classe responsável pela execução do cálculo.
Este método startObservation é chamado assim que o usuário clica no botão. Eu tentei fazer com que o método disparasse uma exception quando o processo tivesse terminado, assim eu a trataria no evento do botão e enviaria a mensagem ao usuário, porèm isso não deu certo já que usando o Timer, as TimerTasks são executadas em Threads separadas e ao passar no if (filiais == null) o vetor contém elementos e a tela fica presa.
Agradeço desde já a ajuda.

#2

Eu não consigo ver onde vc usou o padrão observer, mas deixe que lhe diga o seguinte:

Vc precisa de um objecto que recebe eventos. Quando uma tarefa termina ela usa o evento para informar esse objecto
que terminou. Quando todas tiverem terminado, o processo está pronto.
Por outro lado vc não precisa de Timer ou Timetask, apenas Runnable e/ou Thread


class TaskObserver {

   
  
    public void onTaskTerminated() {
          terminated++;

           if (terminated == NumeroMáximoDeTarefas) {
                 this.notifyAll(); // sinaliza que pode deixar de esperar
          } 
   }

   public void start () {
         terminated = 0;

          for (int i =0 ; i < NumeroMáximoDeTarefas;i++){
                   TaskExecutorThread tet = new TaskExecutorThread (this);
                    tet.start();
         }

         this.wait(); // espera até terminar todo o mundo
   }


}


class TaskExecutorThread  extends Thread {
 
    private TaskObserver observer
    TaskExecutorThread  (TaskObserver  observer){
          this.observer = observer;
    }

     public void run(){
           // faz calculos

          observer.onTaskTerminated();
     }

}

Em Java 6 existem as classes Executor , Queue e Future que podem ser usadas para deixar o codigo melhor e mais simples
de entender. Se puder usar Java 6 dê uma olhadan elas

#3