Runable, Callable, Future, FutureTask, ExecutorService, Exctor, Excutores e ThreadpoolExcetor em Java resume essas palavras -chave e seu uso.
Primeiro os classificam:
Executável, chamável
Futuro, FutureTask
ExecutorService, Exctor, Excutores, ThreadpoolExcetor
1. Sobre o Rentable and Callable
Primeiro de tudo, existem três maneiras de criar tópicos em Java:
Vantagens e desvantagens de três implementações:
Devido ao tópico herdador, outras classes não podem ser herdadas e o thread atual que isso pode ser obtido.
Implementar a interface executável, sem valor de retorno, obtenha o thread atual.CurrentThread ()
Implementar a interface chamada, você pode obter o valor de retorno através do futuro.get () e obter o thread atual.CurrentThread ()
Tópico herdando, duas etapas:
classe Demothread estende thread {@Override public void run () {super.run (); // executa operação de consumo de tempo ...}} Demothread t = new Demothread (); t.start ();Para implementar o Runable, geralmente use o seguinte:
novo thread (novo runnable () {@Override public void run () {// faça algo}}). start ();Por simplicidade.
É bastante problemático obter os resultados da execução do encadeamento nos dois métodos acima e não pode ser obtido diretamente. O JDK1.5 adiciona chamadas, o método Call de Callable () para retornar valores e lançar exceções. Callable pode retornar um objeto futuro carregado com os resultados do cálculo.
Código fonte chamável:
interface pública Callable <V> {V Call () lança exceção;}Uso básico do chamável:
FutureTask <Integer> FutureTask = new FutureTask <Integer> (novo Callable <Teger> () {@Override public Integer Call () lança exceção {// Faça algo retornar null;}}}); Thread = Thread = new Thread (FutureTask ).start ();}});A execução da tarefa chamada pode obter um objeto futuro e obter o valor de retorno executado pelo thread através do método get () do futuro. Então ... futuro,
Qual é a diferença entre o FutureTask e como usá -lo?
-> Next ()
2. Sobre o futuro e o FutureTask
Para obter os resultados da execução do tópico, foi introduzido o FutureTask do Future. Então, qual é o relacionamento deles e como usá -lo?
A classe futura está localizada no pacote java.util.Concurrent, que é uma interface:
interface pública Future <V> {cancelamento boolean (boolean mayinterruptifrunning); booleano iscanceled (); boolean Isdone (); V get () lança interruptedException, executionException; V Get (tempo limite de longa data, unidade timeunit) lança interruptedException, executionException, timeoutException;}Futuro define 5 métodos:
1) cancelamento booleano (booleano MayInterruptifrunning): Tente cancelar a execução desta tarefa. Se a tarefa tiver sido concluída ou foi cancelada ou não puder ser cancelada por algum outro motivo, essa tentativa falhará. Quando o cancel () é chamado, se a chamada for bem -sucedida e a tarefa não tiver sido iniciada, a tarefa nunca será executada. Se a tarefa tiver sido iniciada, o parâmetro MayInterruptifrunning determina se o thread que executa a tarefa deve ser interrompido de uma maneira que tenta interromper a tarefa. Depois que esse método retorna, as chamadas subsequentes para o iSDONE () sempre retornarão true. Se esse método retornar TRUE, as chamadas subsequentes para iscanceled () sempre retornarão verdadeiras.
2) BOOLEAN ISCANCELLED (): Retorne true se a tarefa for cancelada antes de concluir normalmente.
3) BOOLEAN ISDONE (): Retorne true se a tarefa tiver sido concluída. Isso pode ser feito devido ao término normal, exceção ou cancelamento, em todos esses casos, esse método retornará verdadeiro.
4) v get () lança interruptedException, executionException: se necessário, aguarde a conclusão do cálculo e obtenha seu resultado.
5) V Get (tempo limite de longo prazo, unidade de unidade de tempo) lança interruptedException, executionException, timeoutException: se necessário, aguarde no máximo após o tempo determinado para concluir o cálculo e obter o resultado (se o resultado estiver disponível).
Em geral, o futuro fornece três funções:
Determinar se a tarefa é concluída;
Capacidade de interromper tarefas;
Capaz de obter resultados de execução de tarefas.
Pontos -chave:
RunnableFuture herda a interface executável e a interface futura, enquanto o FutureTask implementa a interface RunnableFuture.
Implementação do FutureTask:
Public Class FutureTask <V> implementa RunnableFuture <V>
Implementação da interface RunnableFuture:
interface pública RunnableFuture <V> estende Runnable, Future <V> {void run ();}O FutureTask é uma classe de implementação exclusiva da interface futura.
Além de encerrar o FutureTask com threads, há outra maneira de usá -lo:
ExecutorService executor = executores.newcachedThreadpool (); futureTask <Teger> FutureTask = new FutureTask <Teger> (novo callable <Teger> () {@Override IntelTer Call () lança excepção {// fazer algo de retorno nulo;}}); A estrutura do executor é usada aqui.
-> seguinte ();
3. Sobre ExecutorService, Exctor, Excutores, ThreadpoolExcetor
A estrutura do executor foi introduzida no Java 5. A estrutura do executor é uma estrutura que executa tarefas assíncronas que executam chamadas de política, cronogramas, executa e controles.
Antes de falar sobre a estrutura do executor, precisamos introduzir um novo conceito - ThreadpoolExector:
Public ThreadPoolExecutor (IntcorePoolSize, int maximumPoolSize, Longo KeepAlivETime, Unidade Timeunit, BlockingQueue <unnable> WorkQueue, ThreadFactoryfactory, rejejeTexecutionHandler Handler)
ThreadpoolExecutor é a implementação subjacente da classe Executores.
Na documentação do JDK Ajuda, há uma passagem:
"É altamente recomendado que os programadores usem os executores de fábrica de executores mais convenientes.
Então, o que são ExecutorService, Exctor e Excutores?
Exctor é uma interface central no nível de abstração:
Executor de interface pública {void Execute (comando runnable);}A interface ExecorService estende a interface do executor e fornece métodos como retornar objetos futuros, encerrar, fechar os pools de threads, etc.
interface pública ExecutorService estende o executor {void Shutdown (); <T> FUTURO <T> Enviar (Tarefa Callable <T>); <T> FUTURO <T> Enviar (tarefa executável, resultado t); <T> List <Future <T>> InvoKeall (coleção <? Extende as tarefas chamáveis <T>>, Timeout longo, unidade de unidade de tempo) lança interruptedException;}Executores é uma classe de ferramentas semelhante às coleções. Fornece métodos de fábrica para criar diferentes tipos de pools de threads, como FILLTHREADPOOL ou CACHEDTHREADPOOL.
public class executores {public static executorService newfixedthreadpool (int nthreads) {return new threadpoolExecutor (NTHREADS, NTHREADS, 0L, timeUnit.millisEconds, novo LinkedBlockQueue <nnable> ()); } public static executorService newcachedthreadpool () {return new ThreadpoolExecutor (0, Integer.max_value, 60l, timeUnit.Seconds, novo síncronosqueue <unnable> ()); }}O exposto acima é uma compilação de palavras-chave com vários threads Java, por isso não será confuso.
O exposto acima é a implementação da classificação de palavras-chave com vários threads em Java introduzido pelo editor. Espero que seja útil para todos. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a todos a tempo. Muito obrigado pelo seu apoio ao site wulin.com!