SpringBoot usar o pool de threads

O uso rotineiro do pool de threads:

classe de mensagem, chamando o pool de threads

{Classe MessageClientSendMsg pública 

    / ** 
     * logger 
     * / 
    Privado O registrador Log = new new estática final do Log (MessageClientSendMsg.class); 

    / ** 
     * segmento pool 
     * / 
    private static ExecutorService ThreadPool; 

    / ** 
     * o traço 
     * / 
    Privado Cordas do traço ; 

    / ** 
     * número de telefone 
     * / 
    privado Cordas cellNum; 

    / ** 
     * entidade mensagem 
     * / 
    privados messageProducerReq messageProducerReq; 

    estática { 
        ThreadPool = Executors.newFixedThreadPool (10); // número de pool de threads fixo 
    } 

    / **  
     * configuração função
     * 
     * @Param solicitar a água do traço 
     * número de telefone @param cellNum 
     * mensagem entidade messageProducerReq @ param 
     * / 
    MessageClientSendMsg público (o traço String, String cellNum, MessageProducerReq messageProducerReq) { 

        this.trace = o traço; 
        this.cellNum = cellNum; 
        this.messageProducerReq = messageProducerReq; 
    } 

    / ** 
     * mensagem 
     * / 
    public void sendmsg () { 

        SendMsgRunable sendMsgRunable novas novas = SendMsgRunable (); 

        threadPool.execute (sendMsgRunable); 
    } 

    / ** 
     * envio de mensagem de manipulação de classe e anormalidades internas, não afeta o segmento principal negócios 
     * /
    implementos classe SendMsgRunable Runnable {
 
        @Override
        public void run () { 

            try { 
                MessageClientProducer msgClintProducer = new MessageClientProducer (); 
                msgClintProducer.sendAsyncWithPartition (traço, cellNum, messageProducerReq); 
            } Catch (Exception e) { 
                LOGGER.error ( "消息发送失败, traço:" + traço); 
            } 
        } 
    } 
}

SpringBoot usar o pool de threads usando anotações e notas @EnableAsync @Async

Configurando pools de threads:

java.util.concurrent.ThreadPoolExecutor, Importação; 

@Configuration 
@EnableAsync 
classe pública BeanConfig { 

    @Bean 
    pública de TaskExecutor, taskExecutor () { 
        a ThreadPoolTaskExecutor é o ThreadPoolTaskExecutor é executor novas novas = (); 
        // Set o número de threads de núcleo 
        executor.setCorePoolSize (5.); 
        // definir o máximo tópicos 
        executor.setMaxPoolSize (10); 
        // definir a capacidade da fila 
        executor.setQueueCapacity (20 é); 
        // conjunto tempo rosca activo (s) 
        executor.setKeepAliveSeconds (60); 
        // conjunto de nome de rosca padrão 
        executor.setThreadNamePrefix ( "Olá- "); 
        // conjunto de políticas negar
        executor.setRejectedExecutionHandler (nova nova ThreadPoolExecutor.CallerRunsPolicy ()); 
        // espera para todas as tarefas para fechar após o fim do pool de threads 
        executor.setWaitForTasksToCompleteOnShutdown (a verdade); 
        retorno Executor; 
    } 
}

operações simultâneas:

importação org.springframework.scheduling.annotation.Async; 
importação org.springframework.stereotype.Component; 
importação java.text.SimpleDateFormat; 
importação java.util.Date; 


@Component 
public class Teste { 
    @Async 
   teste public void (int i) { 
        formato SimpleDateFormat = new SimpleDateFormat ( "HH: mm: ss"); 
        try { 
            Thread.sleep (10000); 
            System.out.println ( "多线程异步执行" + i + " "+ Thread.currentThread () getName () +"." + Format.format (new Date ())); 
        } Catch (InterruptedException e) { 
            e.printStackTrace (); 
        } 
    } 
}

utilizações camada controlador

@GetMapping ( "/ test") 
@ResponseBody 
teste public void () { 
    for (int i = 0; i <100; i ++) { 
         Test.Test (i); 
    } 
}