Qual coleção usar? (pool de threads com exclusividade) [RESOLVIDO]

if (! isAtivo(runnable)){//dá um contains na coleção pra ver se o elemento já existe
				setAtivo (runnable,true); //adiciona ou remove à coleção dependendo do segundo parâmetro
				pool.execute(new InternalRunnable (runnable));
			}

if (setAtivo (runnable,true)){//adiciona somente se o elemento não existir. Economizei um contains aqui.. hehehe
			pool.execute(new InternalRunnable (runnable));
		}

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Gerenciador de threads. Garante que, em determinado instante, somente haverá uma thread executando sobre um determinado
 * objeto. Os objetos passados para o método executar, além de implementar Runnable, devem implementar equals e hashcode para
 * que a classe consiga determinar quais objetos estão ativos em determinado instante.
 * @author Rodrigo Bossini
 * @since 02/02/2010
 * */
public class ExclusiveThreadManager {

	
	private ExecutorService pool;
	private Set <Runnable> ativos = new HashSet<Runnable>();
	/**
	 * Constrói um pool de threads que cresce de acordo com a necessidade. Threads que já terminaram seu serviço permanecem
	 * ativas durante um minuto. Se outra atividade aparecer, uma thread ociosa pode ser reaproveitada. Após um minuto
	 * de ociosidade, a thread é eliminada.
	 * 	@author Rodrigo Bossini
	 *	@since 02/02/2010
	 * */
	public ExclusiveThreadManager(){
		pool = Executors.newCachedThreadPool();
	}
	/**
	 * Costrói um pool de threads com um número de threads igual a numThreads.
	 * 	@author Rodrigo Bossini
	 * 	@since 02/02/2010
	 * */
	public ExclusiveThreadManager (int numThreads){
		pool = Executors.newFixedThreadPool(numThreads);
	}
	
	/**
	 * Verifica (com base nos métodos equals e hashcode) se este objeto runnable está sendo executado atualmente.
	 * Em caso positivo, simplesmente retorna. Em caso contrário, adiciona o mesmo para a fila de execução.
	 * */
	public void executar (Runnable runnable){
		if (setAtivo (runnable,true)){
                         //o runnable a executar é empacotado em um Runnable Interno. O método run deste Runnable interno chamada o método run deste runnable e então exclui o objeto da lista de ativos.
			pool.execute(new InternalRunnable (runnable));
		}
	}
	private boolean setAtivo (Runnable runnable, boolean ativar){
		if (ativar){
			synchronized (ativos){
				return ativos.add(runnable);
			}
		}
		else
		{
			synchronized (ativos){
				return ativos.remove(runnable);
			}
		}
		
	}
	
	private class InternalRunnable implements Runnable{
		private Runnable internalRunnable;
		public void run() {
			try{
				internalRunnable.run();
			}
			finally{
				setAtivo (internalRunnable, false);
			}
		}
		public InternalRunnable (Runnable runnable){
			this.internalRunnable = runnable;
		}
	}
	
	/**
	 * Espera que todas as atividades que já tenham tido o pedido de execução realizado terminem para finalizar o pool de threads.
	 * Depois desta chamada, outras atividades serão rejeitadas.
	 * @author Rodrigo Bossini
	 * @since 02/02/2010
	 * */
	public void fechar (){
		pool.shutdown();
	}
	
	/**
	 * Fecha o pool imediatamente sem se preocupar se ainda existem atividades sendo executadas.
	 * @author Rodrigo Bossini
	 * @since 02/02/2010
	 * */
	public void fecharAgora (){
		pool.shutdownNow();
	}
	
}