SpringBoot utilizar el grupo de subprocesos

El uso rutinario de la agrupación de hebras:

clase de mensaje, llamando a la agrupación de hebras

MessageClientSendMsg pública clase { 

    / ** 
     * registrador 
     * / 
    privado el registro REGISTRADOR = new nueva estática final del registro (MessageClientSendMsg.class); 

    / ** 
     * grupo de subprocesos 
     * / 
    private static ExecutorService ThreadPool; 

    / ** 
     * la traza 
     * / 
    privada Cadena de la traza ; 

    / ** 
     * número de teléfono 
     * / 
    cadena cellNum privada; 

    / ** 
     * entidad mensaje 
     * / 
    messageProducerReq MessageProducerReq privadas; 

    estática { 
        ThreadPool = Executors.newFixedThreadPool (10); // número de grupo de subprocesos fija 
    } 

    / **  
     * configuración función
     * 
     * @Param solicitar el agua traza 
     * @param cellNum número de teléfono 
     * @param mensaje entidad messageProducerReq 
     * / 
    MessageClientSendMsg pública (la traza String, String cellNum, MessageProducerReq messageProducerReq) { 

        this.trace = el rastro; 
        this.cellNum = cellNum; 
        this.messageProducerReq = messageProducerReq; 
    } 

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

        sendMsgRunable sendMsgRunable nuevos nuevos sendMsgRunable = (); 

        threadPool.execute (sendMsgRunable); 
    } 

    / ** 
     * clase de enviar el mensaje de manipulación y anomalías internas, no afectan el hilo principal negocio 
     * /
    implementa la clase SendMsgRunable Ejecutable {
 
        @ Override
        public void run () { 

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

SpringBoot utilizar el grupo de subprocesos mediante anotaciones y notas @EnableAsync @Async

Configuración de grupos de subprocesos:

java.util.concurrent.ThreadPoolExecutor, Import; 

@Configuration 
@EnableAsync 
clase pública BeanConfig { 

    @Bean 
    público del TaskExecutor, TaskExecutor () { 
        el ThreadPoolTaskExecutor es la ThreadPoolTaskExecutor es ejecutor nuevos nuevos = (); 
        // establecer el número de hilos de núcleo 
        executor.setCorePoolSize (5.); 
        // establecer el máximo hilos 
        executor.setMaxPoolSize (10); 
        // establecer la capacidad de la cola 
        executor.setQueueCapacity (20 es); 
        // set tiempo hilo activo (sec) 
        executor.setKeepAliveSeconds (60); 
        // set nombre hilo predeterminada 
        executor.setThreadNamePrefix ( "Hello- "); 
        // set política de denegación
        executor.setRejectedExecutionHandler (nueva nueva ThreadPoolExecutor.CallerRunsPolicy ()); 
        // espera para todas las tareas para cerrar después del final de la agrupación de hebras 
        executor.setWaitForTasksToCompleteOnShutdown (true); 
        retorno Ejecutor; 
    } 
}

operaciones simultáneas:

org.springframework.scheduling.annotation.Async importación; 
org.springframework.stereotype.Component importación; 
java.text.SimpleDateFormat importación; 
java.util.Date importación; 


@Component 
public class Prueba { 
    @Async 
   prueba 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 (); 
        } 
    } 
}

usos capa del controlador

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