Estou estudando sobre Java, e me deparei com a interface Future do java.util.concurrent. Eu dei uma pesquisada na net, porém não achei nada que me sanasse dúvidas... Então gostaria de saber aqui se alguém conseguiria…

Aqui tem um link onde é possível baixar um PDF: http://uaihebert.com/?page_id=439 Esse PDF mostra como utilizar o Future com EJB.

Dúvida Future

É um objeto utilizado para verificar o resultado de um processamento assíncrono, ou seja, um processamento que será executado em uma thread separada da thread principal do programa. Como você não sabe quando esta outra thread irá terminar ou quanto tempo irá durar o processamento, o objeto Future permite que você consulte estas informações de tempos em tempos, que cancele a execução da tarefa ou espere ela executar até o final.

package teste.concorrencia;

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


/**
 * Esta classe mostra o funcionamento dos objetos Future. Eles servem para receber o resultado de uma execução <br></br>
 * de alguma atividade que foi submetida para ser executada em alguma thread do pool.							<br></br>
 * 
 * 
 * @author Rogério de Paula Aguilar (04/2012)
 * 
 * */
public class TesteFuture {

	final ExecutorService exec = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()+1);
	
	/*
	 * Esta classe simula um processamento qualquer que pode durar até 10 segundos
	 * */
	class TesteCallable implements Callable<Long> {

		private int x;
		
		public TesteCallable(int x) {
			this.x = x;
		}

		public Long call() throws Exception {
			Random rnd = new Random();
			long sleep = Math.abs(rnd.nextLong()) % 10_000;
			System.out.println("Thread " + x + " - sleeping " + sleep);
			try {
				Thread.sleep(sleep);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return sleep;
		}	
		
	}
	
	/*
	 * Neste teste são criadas 8 tarefas e seus respectivos objetos future. Além disso é criado um array contendo 
	 * o status de execução de cada tarefa. 
	 * As tarefas são então submetidas ao pool e é criado um looping na thread principal do programa que aguarda 
	 * a execução destas tarefas.
	 * */
	
	public void teste() {
		Future f[] = new Future[8];
		//array que guarda o status de 8 tarefas
		boolean tarefasCompletadas[] = {false, false, false, false, false, false, false, false};
		int contTarefas = 0;
		for(int x = 0; x < 8; x++) {
			f[x] = exec.submit(
					new TesteCallable(x)
			);
		}
		do {
			for(int x = 0; x < 8; x++) {
				if(f[x].isDone() && !tarefasCompletadas[x]){
					try {
						System.out.println("&&&&&Completo -> " + f[x].get());
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (ExecutionException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					tarefasCompletadas[x] = true;
					contTarefas++;
					System.out.println("*******CONT --> " + contTarefas);
				}
				try{
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}finally{}
			}
		}while(contTarefas < 7);
		System.out.println("OK");
		exec.shutdown();
	}
	
	public static void main(String[] args) {
			new TesteFuture().teste();
	}

}

2 Respostas

Topicos relacionados