Este artigo analisa o uso do pool de threads Java para sua referência. O conteúdo específico é o seguinte
1. As desvantagens do novo tópico
Você ainda apenas executa um novo thread da seguinte maneira ao executar uma tarefa assíncrona?
novo thread (new Runnable () {@Override public void run () {// TODO Method Auto-Gerated Stub}}). start ();Em seguida, você terá muitas saídas, as desvantagens do novo tópico são as seguintes:
um. O desempenho de um novo tópico é ruim sempre.
b. Os threads não possuem gerenciamento unificado, que podem criar novos threads sem restrições, competir entre si e ocupar muitos recursos do sistema para causar falhas ou ooms.
c. Falta de mais funções, como execução cronometrada, execução periódica, interrupção do thread.
Comparados com o novo thread, as vantagens dos quatro pools de threads fornecidos pela Java são:
um. Reutilize os threads existentes para reduzir a sobrecarga da criação e extinção de objetos e executar bem.
b. Ele pode controlar efetivamente o número máximo de encadeamentos simultâneos, melhorar a taxa de utilização dos recursos do sistema e evitar a concorrência excessiva de recursos e evitar o bloqueio.
c. Fornece funções como execução cronometrada, execução regular, rosqueamento único, controle de número simultâneo, etc.
2. Java Thread Pool
Java fornece quatro tipos de pools de threads através de executores, a saber:
NewcachedThreadpool cria um pool de threads em cache. Se o comprimento do pool de threads exceder as necessidades de processamento, ele poderá reciclar de forma flexível encadeamentos ociosos. Se não houver reciclagem, crie um novo thread.
O newfixedThreadpool cria um pool de encadeamentos de comprimento fixo que pode controlar o número máximo de threads simultaneamente, e os threads em excesso aguardam na fila.
O NewscheduledThreadpool cria um pool de threads de comprimento fixo que suporta a execução de tarefas cronometradas e periódicas.
O NewsingLethreadExecutor cria um pool de threads de thread único, que usará apenas um thread de trabalhador exclusivo para executar tarefas, garantindo que todas as tarefas sejam executadas na ordem especificada (FIFO, LIFO, Priority).
(1) NewCachedThreadpool:
Crie um pool de threads em cache. Se o comprimento do pool de threads exceder as necessidades de processamento, você poderá reciclar de forma flexível encadeamentos ociosos. Se não houver reciclagem, crie um novo thread. O código de amostra é o seguinte:
ExecutorService CachedThreadpool = executores.newcachedthreadpool (); for (int i = 0; i <10; i ++) {final int index = i; tente {thread.sleep (índice * 1000); } catch (interruptedException e) {e.printStackTrace (); } CachedThreadpool.execute (new Runnable () {@OverridePublic void run () {System.out.println (index);}});}O pool de threads é infinito. Quando a segunda tarefa é executada, a primeira tarefa foi concluída e o thread que executa a primeira tarefa será reutilizado sem criar um novo thread sempre.
(2) newfixedthreadpool:
Crie um pool de encadeamentos de comprimento fixo que possa controlar o número máximo de simultaneidade de threads, e o excesso de threads aguardará na fila. O código de amostra é o seguinte:
ExecutorService fIllThreadpool = executores.newfixedthreadpool (3); for (int i = 0; i <10; i ++) {final int index = i; fIllThreadpool.execute (new Runnable () {@OverridePublic void run () {try {System.out.println (index); thread.sleep (2000);} catch (interruptedException e) {// TODO GATO AUTO-GENERADO E.PriNTSTRACE ();}Como o tamanho do pool de threads é 3, durma 2 segundos após cada índice de saída de tarefas, então 3 números são impressos a cada dois segundos.
O tamanho de um pool de threads de comprimento fixo é melhor definido de acordo com os recursos do sistema. Como runtime.getRuntime (). DisponívelProcessors (). Por favor, consulte a pré -adaptaCache.
(3) NewscheduledThreadpool:
Crie um pool de threads de comprimento fixo que suporta a execução de tarefas cronometradas e periódicas. O código de amostra para a execução atrasada é o seguinte:
ScheduleDexecutorService ScheduledThreadpool = Executores.NewsCheduledThreadPool (5); ScheduledThreadpool.schedule (new Runnable () {@OverridePublic void run () {System.out.println ("Atraso 3 segundos");}}, 3, timeunit.Seconds);Indica a execução de atraso em 3 segundos.
O código de amostra é executado regularmente da seguinte maneira:
ScheduledThreadpool.scheduleatfixedrate (new Runnable () {@OverridePublic void run () {System.out.println ("Atraso 1 segundos e escape a cada 3 segundos");}}, 1, 3, TimeUnit.seconds);Isso significa que o atraso é realizado a cada 3 segundos após 1 segundo.
ScheduledExecutorService é mais seguro e mais poderoso que o temporizador
(4) NewsingleThreadExecutor:
Crie um pool de threads de thread único, que usará apenas um thread de trabalhador exclusivo para executar tarefas, garantindo que todas as tarefas sejam executadas na ordem especificada (FIFO, LIFO, prioridade). O código de amostra é o seguinte:
ExecutorService singleThreadExector = executores.newsinglethreadExecutor (); para (int i = 0; i <10; i ++) {final int index = i; singleThreadExecutor.execute (new runnable () {@OverridePublic void Run () {Try {System.out.out.print () {@OverridePublic run () {Try {System.out.out.pri. (InterruptedException e) {// TODO BLOCO DE CATURA AUTOMÁRIO E.PRINTSTACKTRACE ();Os resultados são emitidos na sequência, o que equivale a executar cada tarefa em sequência.
A maioria dos programas atuais da GUI é de thread única. Os threads únicos no Android podem ser usados para operações de banco de dados, operações de arquivo, instalação em lote de aplicativos, exclusão de aplicativos em lote etc., que não são adequados para simultâneos, mas podem bloquear IO e afetar a resposta dos threads da interface do usuário.
A função do pool de threads:
A função de um pool de threads é limitar o número de threads executados no sistema.
Dependendo do ambiente do sistema, o número de threads pode ser definido automaticamente ou manualmente para obter o melhor efeito de operação; Menos recursos do sistema são desperdiçados e mais congestionamento do sistema não é alto. Use um pool de threads para controlar o número de threads e outros threads estão esperando na fila. Depois que uma tarefa é executada, a primeira tarefa é retirada da fila para iniciar a execução. Se não houver processo de espera na fila, esse recurso do pool de threads está esperando. Quando uma nova tarefa precisa ser executada, se houver threads de trabalhadores em espera no pool de threads, ele poderá começar a funcionar; Caso contrário, ele entrará na fila de espera.
Por que usar o pool de threads:
1. Reduz o número de vezes que os threads são criados e destruídos, e cada thread do trabalhador pode ser reutilizado e pode executar várias tarefas.
2. O número de encadeamentos do trabalhador no pool de threads pode ser ajustado de acordo com a capacidade do sistema de impedir que o servidor seja sugado devido ao consumo excessivo de memória (cada encadeamento requer cerca de 1 MB de memória. Quanto mais threads forem abertos, maior a memória consumida e, finalmente, a falha será.
A interface de nível superior do pool de threads em Java é executora, mas estritamente falando, o Executor não é um pool de threads, mas apenas uma ferramenta para executar threads. A interface do Real Thread Pool é o ExecorService.
Várias categorias mais importantes:
ExecutorService: uma verdadeira interface do pool de threads.
ScheduledExecutorService: pode ser semelhante ao Timer/TimerTask, resolvendo problemas que requerem tarefas repetidas.
ThreadPoolExecutor: a implementação padrão do ExecorService.
ScheduledThreadPoolExecutor: uma implementação de classe da interface ScheduleDexecutorService que herda ThreadPoolExecutor, uma implementação da classe de agendamento de tarefas periódicas.
É bastante complicado configurar um pool de threads, especialmente quando o princípio do pool de threads não é muito claro. É muito provável que o pool de threads configurado não seja melhor. Portanto, algumas fábricas estáticas são fornecidas na classe Executores para gerar alguns pools de threads comumente usados.
1.NewsingleThreadExecutor
Crie um único pool de threads. Este pool de threads tem apenas um thread funcionando, que é equivalente a um único thread que executa todas as tarefas no Serial. Se esse thread exclusivo terminar devido à exceção, haverá um novo thread para substituí -lo. Este pool de threads garante que a ordem de execução de todas as tarefas seja executada na ordem do envio da tarefa.
2.NewfixedThreadpool
Crie um pool de threads de tamanho fixo. Cada vez que uma tarefa é enviada, um encadeamento é criado até que o encadeamento atinja o tamanho máximo do pool de encadeamentos. O tamanho do pool de threads permanece o mesmo quando atinge seu valor máximo. Se um thread terminar devido a uma exceção de execução, o pool de threads adicionará um novo thread.
3.NewcachedThreadpool
Crie um pool de threads em cache. Se o tamanho do pool de threads exceder o encadeamento necessário para processar a tarefa,
Em seguida, alguns threads ociosos (nenhuma execução de tarefas em 60 segundos) serão reciclados. Quando o número de tarefas aumenta, esse pool de threads pode adicionar de forma inteligente novos threads para lidar com a tarefa. Este pool de threads não limita o tamanho do pool de threads, que depende inteiramente do tamanho máximo de encadeamento que o sistema operacional (ou JVM) pode criar.
4.NewscheduledThreadpool
Crie um pool de threads de tamanho ilimitado. Este pool de threads suporta a necessidade de executar tarefas periodicamente e periodicamente.
Código de exemplo
1. Pool de threads de tamanho fixo, newfixedthreadpool:
pacote app.executores; importar java.util.concurrent.executores; importar java.util.concurrent.executorService; / ** * thread java: thread pool * * @author xiho */ public class Test {public static void main (string [] args) {// Crie um pool de threads com um número fixo de threads reutilizáveis executores Service pool = executores.newfixedthreadpool (2); // crie thread thread t1 = new mythread (); Thread t2 = new mythread (); Thread t3 = new mythread (); Thread t4 = new mythread (); Thread t5 = new mythread (); // coloque o thread no pool para execução pool.execute (t1); Pool.Execute (T2); Pool.Execute (T3); Pool.Execute (T4); pool.execute (T5); // fechar o pool de threads pool.shutdown (); }} classe mythread estende thread {@Override public void run () {System.out.println (thread.currentThread (). getName () + "execução ..."); }}Resultado da saída:
Pool-1-Thread-1 está executando. . . Pool-1-Thread-3 está executando. . . Pool-1-Thread-4 está executando. . . Pool-1-Thread-2 está executando. . . Pool-1-Thread-5 está sendo executado. . .
Altere os parâmetros no executorService pool = executores.newfixedthreadpool (5): executores Service pool = executores.newfixedthreadpool (2), e o resultado da saída é:
Pool-1-Thread-1 está executando. . . Pool-1-Thread-1 está executando. . . Pool-1-Thread-2 está executando. . . Pool-1-Thread-1 está executando. . . Pool-1-Thread-2 está executando. . .
A partir dos resultados acima, podemos ver que o parâmetro do newfixedThreadpool especifica o número máximo de threads que podem ser executados. Depois de adicionar mais do que esse número de threads, eles não funcionarão. Em segundo lugar, os threads adicionados ao pool de threads estão no estado gerenciado e a operação do thread não é afetada pela ordem de união.
2. Pool de threads de tarefas únicas, NewsingleThreadExecutor:
Basta alterar o Pool ExecutorService = Execors.NewfixedThreadpool (2) no código acima para executores Service Pool = executores.NewsingleThreadExecutor ();
Resultado da saída:
Pool-1-Thread-1 está executando. . . Pool-1-Thread-1 está executando. . . Pool-1-Thread-1 está executando. . . Pool-1-Thread-1 está executando. . . Pool-1-Thread-1 está executando. . .
Pode-se observar que toda vez que você chama o método Execute, o método Run Thread-1 é realmente chamado no final.
3. Pool de threads de tamanho variável, newcachedthreadpool:
Semelhante ao exposto, basta alterar a maneira como o pool é criado: ExecutorService pool = executores.newcachedthreadpool ();
Resultado da saída:
Pool-1-Thread-1 está executando. . . Pool-1-Thread-2 está executando. . . Pool-1-Thread-4 está executando. . . Pool-1-Thread-3 está executando. . . Pool-1-Thread-5 está sendo executado. . .
Este método é caracterizado pelo fato de que novos pools de threads podem ser criados conforme necessário, mas serão reutilizados quando threads construídos anteriormente estiverem disponíveis.
4. Pool de conexão de atraso, NewsCheduledThreadpool:
classe pública testscheduledthreadpoolExecutor {public static void main (string [] args) {scheduledThreadpoolExecutor Exec = new ScheduledThreadPoolExector (1); Exec.scheduleatfixedrate (new Runnable () {// A exceção é acionada de vez em quando @Override publicVoid run () {// lança new RunTimeException (); System.out.println ("=========================================================================================================================== ==================================================================================================== ==================================================================================================== ==================================================================================================== TimeUnit.MillisEconds);Resultado da saída:
================ 8384644454951683866438290348388643830710 =============== 8390643851383839264387999319319306438383839264387999930
O exposto acima é tudo sobre este artigo, espero que seja útil para o aprendizado de todos.