Fila de requisições

Programação Java
#1

Olá a todos…

Estou querendo fazer uma classe que trabalhe como uma fila… por exemplo, várias outras classes vão chamar esse classe e ela irá enfileirar as requisições dessas classes, e executando uma a uma… quando acabar de executar a primeira requisição, ela sai da fila e a nova requisição é executada…
Sendo que as classes que chamam essa classe que enfileira as requisições tem que esperar pelo retorno do resultado para continuar o seu código.

Acho que fui bem claro, alguém tem alguma idéia?

#2

Dá uma pesquisada sobre synchronize:
http://java.sun.com/docs/books/tutorial/essential/concurrency/syncmeth.html

#3

Isso eh facil de fazer, na verdade a própria api te da isso pronto, de uma lida na api de concurrent que faz parte da JSE (a partir da versao 5 do java):
http://www.argonavis.com.br/cursos/java/j100/java-5-concurrent.pdf

Exemplo:

       import java.util.concurrent.Callable;
       import java.util.concurrent.ExecutionException;
       import java.util.concurrent.Future;
       ....
	public static void main(String[] args) throws InterruptedException,
			ExecutionException {
		final Callable<Integer> task1 = new Callable<Integer>() {
			public Integer call() throws Exception {
				Thread.sleep(5000);
				System.out.println("task 1");
				return 1;
			}
		};
		final Callable<Integer> task2 = new Callable<Integer>() {
			public Integer call() throws Exception {
				Thread.sleep(1000);
				System.out.println("task 2");
				return 2;
			}
		};
		// mando executar as duas tasks (isso seria mandar uma requisicao a ser
		// processada no seu sistema)
		Future<Integer> f1 = SuaClasseFila.exec(task1);
		Future<Integer> f2 = SuaClasseFila.exec(task2);

		// qdo faz um get em um objeto Future (java.util.concurrent.Future), ele
		// trava e espera o retorno (ateh que seja processado), isso iria
		// caracterizar a classe chamadora esperar pelo resultado, porem dando a
		// vantagem de ela nao esperar :P ou seja, fica melhor, ela espera se quiser
		System.out.println(f1.get());
		System.out.println(f2.get());
	}

E aqui a sua classe “fila” executora

        import java.util.concurrent.Callable;
        import java.util.concurrent.ExecutorService;
        import java.util.concurrent.Executors;
        import java.util.concurrent.Future;

	public class SuaClasseFila {
		// aqui cria um executor com no maximo 1 thread, ou seja, executa uma
		// coisa de cada vez, esperimente colocar 2 ali, vc vai ver que a task1
		// e task2 vaum executar concorrentemente, mas como vc quer uma execução
		// em fila, o valor ideial sera 1
		public static ExecutorService e = Executors.newFixedThreadPool(1);

		public static <T> Future<T> exec(Callable<T> task) {
			return e.submit(task);
		}
	}

Preste atenção nisso:

ExecutorService e = Executors.newFixedThreadPool(1)
#4