Programação paralela usando chamadas e futuro
A maneira mais comum de executar a programação paralela em Java é herdar a classe Thread ou implementar a interface executável. A desvantagem desses dois métodos é que o resultado da execução não pode ser obtido diretamente após a conclusão da tarefa e deve ser comunicada por meio de variáveis compartilhadas ou inter-friplas, o que é inconveniente de usar.
A partir do Java 1.5, são fornecidas interfaces chamáveis e futuras. Ao usá -los, você pode obter o resultado da execução após a execução da tarefa.
Vamos aprender a usar o Callable, Future e FutureTask.
Interface chamada
A interface chamada está localizada no pacote java.util.Concurrent. Esta é uma interface genérica que apenas declara um método de chamada ():
interface pública Callable <T> {T Call () lança Exception;}Geralmente, é usado em conjunto com a interface ExecorService. Vários métodos de submissão sobrecarregados são declarados na interface ExecutService:
<T> FUTURO <T> Enviar (Tarefa Callable <T>); <T> Future <T> Enviar (Tarefa Runnable, resultado T); Future <?> Enviar (Tarefa Runnable);
O tipo de parâmetro no primeiro método de envio é chamável e os outros dois não são cobertos por este artigo por enquanto.
Future e FutureTask
A classe de implementação da interface futura pode executar operações como cancelamento, consulta e obtenção de resultados em tarefas executáveis ou chamáveis.
A interface futura também está localizada no pacote java.util.Concurrent:
interface pública Future <T> { /***Cancelar tarefa*@param MayInterruptifrunning*permite o cancelamento de tarefas que estão sendo executadas, mas não concluídas? Se o true for definido, significa que a tarefa no processo pode ser cancelada *Se a tarefa estiver sendo executada, ele retornará verdadeiro *Se a tarefa ainda não foi executada, ele retornará verdadeiro se o que pode interromper o cancelamento); /***A tarefa é cancelada com sucesso? Se for cancelado com sucesso antes que a tarefa seja concluída normalmente, retornará verdadeiro */ boolean iscancelled (); / ***A tarefa será concluída*/ boolean ISDONE (); / ***Obtenha o resultado da execução através do bloqueio*/ t get () lança interruptedException, executionException; /***Obtenha o resultado da execução através do bloqueio. Se nenhum retorno for retornado dentro do tempo especificado, retorne nulo */ t Get (tempo limite de longa data, unidade de unidade de tempo) lança interruptedException, executionException, timeoutException;}Em resumo, o Future fornece três funções:
Determine se a tarefa é concluída e pode interromper a tarefa e obter o resultado da execução da tarefa
O JDK nos fornece uma futura classe de implementação da interface FutureTask, que possui os dois construtores a seguir.
public FutureTask (Callable <T> Callable) {} public FutureTask (Runnable Runnable, T resultado) {} Código de amostra
Usando chamadas, futuro
importar java.util.Concurrent.*; Public class Test {public static void main (string [] args) {executService executService = executores.newcachedthreadpool (); Tarefa de tarefa = new tarefa (); Futuro <Teger> FUTURO = ExecutorService.SubMit (Task); executorService.shutdown (); System.out.println ("O encadeamento principal está executando a tarefa ..."); tente {thread.sleep (2000); } catch (interruptedException ex) {ex.printStackTrace (); } tente {System.out.println ("Resultado da execução da tarefa:"+futura.get ()); } catch (interruptedException ex) {ex.printStackTrace (); } catch (ExecutionException Ex) {Ex.PrintStackTrace (); } System.out.println ("Todas as tarefas foram executadas"); }} classe Tarefa implementa Callable <Teger> {@Override public Integer Call () lança a Exceção {System.out.println ("Thread Child está executando a tarefa ..."); // tarefa de simulação leva tempo thread.sleep (5000); retornar 1000; }}Resultados da execução:
O encadeamento infantil está executando a tarefa ... o tópico principal está executando a tarefa ... Operação da tarefa Resultado: 1000 Todas as tarefas foram executadas
Use candidato, FutureTask
importar java.util.Concurrent.*; Public class Test {public static void main (string [] args) {executService executService = executores.newcachedthreadpool (); Tarefa de tarefa = new tarefa (); FutureTask <Integer> FutureTask = new FutureTask <Integer> (Task); executorService.submit (FutureTask); executorService.shutdown (); System.out.println ("O encadeamento principal está executando a tarefa ..."); tente {thread.sleep (2000); } catch (interruptedException ex) {ex.printStackTrace (); } tente {System.out.println ("Resultado da execução da tarefa:"+futureTask.get ()); } catch (interruptedException ex) {ex.printStackTrace (); } catch (ExecutionException Ex) {Ex.PrintStackTrace (); } System.out.println ("Todas as tarefas são executadas"); }} classe Tarefa implementa Callable <Teger> {@Override public Integer Call () lança Exceção {System.out.println ("O encadeamento Child está executando a tarefa ..."); // simulando a tarefa toma thread.sleep (5000); retornar 1000; }}Resultados da execução:
O encadeamento infantil está executando a tarefa ... o tópico principal está executando a tarefa ... Operação da tarefa Resultado: 1000 Todas as tarefas foram executadas
Resumir
O exposto acima é todo o conteúdo deste artigo sobre o uso de chamadas e futuro para programação paralela em Java. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!