[Base] pool de threads java

Por que usar um pool de threads

Passe piscina para multithreading, que de acordo com o sistema podem efetivamente controlar o número de threads de execução, resultados operacionais ótimas. pool de threads para fazer o trabalho é principalmente para controlar o número de threads em execução, a tarefa será colocada no processo de fila e, em seguida, iniciar essas tarefas após a criação da linha, se o número de linhas excede o número máximo, então o número de threads além espera, e outros o fio está terminado, em seguida, remover a partir da fila para executar a tarefa.

características conjunto de encadeamentos

multiplexing fio
O número máximo de controlo em paralelo
fio de Gestão

Vantagem do pool de threads
Reduzir o consumo de recursos, para reduzir a criação da linha e destruição causada pelo consumo através da reutilização de tópicos que foram criados.
Correspondente aumento de velocidade, quando a missão chega, a tarefa pode não precisa esperar até a criação thread pode ser implementada imediatamente.
Melhorar a capacidade de gerenciamento do fio, o fio é um recurso escasso, se a criação ilimitada, não só consome recursos do sistema, mas também reduzir a estabilidade de decência, usando tópicos podem ser unificados distribuição, regulação e monitoramento.

Várias maneiras de criar um fio
Tópico herança
implementar Runnable
implementar mobilizável

Como usar o pool de threads
Arquitetura pool de threads

de Codificação
Executors.newSingleThreadExecutor (): Apenas uma thread do pool de threads, então todas as tarefas apresentadas são executadas sequencialmente
Executors.newCachedThreadPool (): Há um monte de threads do pool precisam ser realizadas ao mesmo tempo, os velhos tópicos disponíveis para ser re-desencadear uma nova execução da tarefa, se tópicos não execução dentro de mais de 60 segundos, ele vai ser encerrado e removido da piscina
Executors.newFixedThreadPool (): tem um número fixo de segmentos no pool de threads, se não houver a execução da tarefa, o segmento irá aguardar
Executors.newScheduledThreadPool (): usado para agendar tarefas a serem executadas no pool de threads

Executors.newWorkStealingPool (): newWorkStealingPool adequado para uso em uma operação muito demorada, mas newWorkStealingPool não extensão ThreadPoolExecutor, é uma extensão da nova classe pool de threads ForkJoinPool, mas são implementados em uma classe Executores uniformes, uma vez razoável usando o CPU da operação de tarefa (funcionamento em paralelo), é adequado para uso em uma tarefa muito demorada

ThreadPoolExecutor

ThreadPoolExecutor estrangeira como o pacote java.util.concurrent fornece a implementação subjacente, na forma de uma piscina rosca interna fornecer gestão externa da execução da tarefa, programação fio, serviços de gerenciamento de pool de segmentos e assim por diante.

Vários parâmetros importantes pool de threads introdução

parâmetros	efeito
corePoolSize	O tamanho do núcleo pool de threads
maximumPoolSize	O tamanho máximo do pool de threads
KeepAliveTime	CorePoolSize pool de threads excede o número de segmentos ociosos tempo máximo de sobrevivência, você pode allowCoreThreadTimeOut (true) para que o tempo efetivo do fio do núcleo
TimeUnit	unidade de tempo KeepAliveTime
WorkQueue	Tarefas que bloqueiam a fila
ThreadFactory	Nova fábrica de fio
RejectedExecutionHandler	Ao apresentar um número de tarefas excede soma maxmumPoolSize + WorkQueue, a tarefa será a de lidar com RejectedExecutionHandler

Fale sobre as obras pool de segmentos subjacentes

Quanto mais enganosa é: a relação entre corePoolSize, maximumPoolSize, WorkQueue.

Quando o pool de threads é inferior a corePoolSize, enviar nova tarefa irá criar um novo segmento para executar a tarefa, mesmo que neste momento há um pool de thread livre.
Quando o pool de threads atinge corePoolSize, enviar nova tarefa será colocado WorkQueue, as tarefas piscina segmento de espera programadas para execução.
Quando WorkQueue maior plena e maximumPoolSize que corePoolSize, tarefa recém-submetido cria uma nova thread para executar tarefas.
Ao apresentar um número de tarefas excede maximumPoolSize, apresentar novas tarefas manipulados por RejectedExecutionHandler.
Quando um thread do pool sobre corePoolSize, tempo ocioso para chegar KeepAliveTime, encerre segmentos ociosos.
Quando definido allowCoreThreadTimeOut (true), o idle thread pool tópicos para KeepAliveTime corePoolSize também fechou.

Ambiente definir parâmetros razoáveis na produção de pool de threads

Que estratégia é rejeitar o pool de threads

Fila de espera está cheia, nunca iria caber novas tarefas, enquanto o número de threads no pool de threads atingiu o número máximo de segmentos, não podemos continuar a servir como uma nova tarefa.

Segmento pool de política de negar

AbortPolicy: manipulador recusou-se a jogar um RejectedExecutionException de tempo de execução
CallerRunsPolicy: executando chamadas de rosca executar a tarefa em si. Esta política fornece um mecanismo de controle de feedback simples, a velocidade pode retardar a apresentar novas tarefas.
DiscardPolicy: não pode executar a tarefa será eliminado
DiscardOldestPolicy: Se a execução do programa não foi fechado, está localizado à frente da fila de trabalho missão será excluído, e tente novamente a execução do programa (Se falhar novamente, repita este procedimento)

Você único no trabalho dos três métodos para criar um pool de threads de número fixo e variável, que você usar mais super-pit

Se o leitor está em Java bloqueando fila de compreendê-lo, veja aqui nós pode ser capaz de entender o porquê.

Java, existem duas principais BlockingQueue alcançar, nomeadamente ArrayBlockingQueue e LinkedBlockingQueue.

ArrayBlockingQueue matriz é implementado por uma capacidade limitada de filas de bloqueio deve ser fornecida.

LinkedBlockingQueue uma lista ligada é capacidade da fila bloqueando delimitada implementado pode ser configurado para seleccionar, se não for definido, a fila é um, o comprimento sem bloqueio limite máximo de Integer.MAX_VALUE.

O problema aqui reside em: não definida, será uma fronteira sem bloqueio fila de um comprimento máximo de Integer.MAX_VALUE. Isto é, se não o fizermos set capacidade LinkedBlockingQueue, então sua capacidade padrão será Integer.MAX_VALUE.

E quando você cria LinkedBlockingQueue newFixedThreadPool, a capacidade não é especificado. Neste ponto, LinkedBlockingQueue é uma fila sem fronteiras, a fila para um sem fronteiras, pode ser continuamente adicionado à fila de tarefas, caso em que é possível porque muitas tarefas e levar a estouro de memória.

Os problemas acima mencionados, principalmente em newFixedThreadPool e newSingleThreadExecutor dois métodos de fábrica, não dizer newCachedThreadPool e newScheduledThreadPool dois métodos para fixar o número máximo de threads criadas por estes dois métodos podem ser Integer.MAX_VALUE, criou tanto Thread, inevitavelmente pode levar a OOM.

Como o trabalho prático é usar o pool de threads, seja através de costume uso pool de threads

thread pool personalizado

import java.util.concurrent.*;

/**
 * 第四种获得java多线程的方式--线程池
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(3, 5, 1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
//new ThreadPoolExecutor.AbortPolicy();
//new ThreadPoolExecutor.CallerRunsPolicy();
//new ThreadPoolExecutor.DiscardOldestPolicy();
//new ThreadPoolExecutor.DiscardPolicy();
        try {
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

A alocação racional dos pool de threads se você está considerando

-Intensivo da CPU

meios intensiva da CPU que a tarefa exige muito de computação, sem obstrução, corridas de CPU em plena velocidade.
O mínimo possível o número de tópicos das tarefas CPU-intensivo, normalmente o número de núcleos de CPU + piscina tópicos de 1 de rosca.

IO-intensiva

Desde o fio tarefa IO-intensiva nem sempre foi em uma missão, você pode atribuir um pouco mais do que o número de tópicos, tais como CPU * 2.
Também é possível utilizar a fórmula: CPU Auditoria / (l - factor de bloqueio); em que um factor de bloqueio entre 0,8-0,9.