JDK线程池

 

JDK普通线程池

@RunWith(SpringRunner.class)
@SpringBootTest
@ContextConfiguration(classes = CommunityApplication.class)
public class ThreadPoolTests {
    private  final Logger logger=  LoggerFactory.getLogger(ThreadPoolTests.class);
    //JDK普通线程池
    private ExecutorService executorService= Executors.newFixedThreadPool(5);
    private void  sleep(long m){
        try {
            Thread.sleep(m);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void testExecutorService(){
        Runnable task=new Runnable() {
            @Override
            public void run() {
                logger.debug("Hello ExecutorService");
            }
        };
        for(int i=0;i<10;i++){
            //调用submit方法,线程池会分配一个线程进行执行这个任务
            executorService.submit(task);
        }
        sleep(10000);
    }

JDK可执行定时任务线程池

public class ThreadPoolTests {
    private  final Logger logger=  LoggerFactory.getLogger(ThreadPoolTests.class);
    //JDK可执行定时任务线程池
    private ScheduledExecutorService scheduledExecutorService=Executors.newScheduledThreadPool(5);
    private void  sleep(long m){
        try {
            Thread.sleep(m);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void  testScheduledExecutorService(){
        Runnable task=new Runnable() {
            @Override
            public void run() {
                logger.debug("Hello ScheduledExecutorService");
            }
        };
        //以多少周期进行执行任务
        scheduledExecutorService.scheduleAtFixedRate(task,10000,20000, TimeUnit.MILLISECONDS);
        sleep(20000);
    }

Spring线程

配置参数

#TaskExecutionProperties
spring.task.execution.pool.core-size=5;//核心线程池的大小
spring.task.execution.pool.max-size=15;//线程池最大的大小
spring.task.execution.pool.queue-capacity=100;//任务队列的大小



#TaskSchedulingProperties
spring.task.scheduling.pool.size=5;//线程池的大小

编写配置类

@Configuration
@EnableScheduling//通过@EnableScheduling注解开启对计划任务的支持
@EnableAsync//启用Spring的异步方法执行功能
public class ThreadPoolConfig {
}

Spring普通线程池

  //Spring普通线程池
   @Autowired
    private ThreadPoolExecutor taskExecutor;
   @Test
    public void textThreadPoolTaskExecutor(){
       Runnable task=new Runnable() {
           @Override
           public void run() {
               logger.debug("Hello ThreadPoolExecutor");
           }
       };
       for(int i=0;i<10;i++){
           //调用submit方法,线程池会分配一个线程进行执行这个任务
           taskExecutor.submit(task);
       }
       sleep(20000);
   }

Spring可执行定时任务线程池

//Spring可执行定时任务线程池
   @Autowired
    private ThreadPoolTaskScheduler taskScheduler;
   @Test
    public  void testThreadPoolTaskScheduler(){
       Runnable task=new Runnable() {
           @Override
           public void run() {
               logger.debug("Hello ThreadPoolTaskScheduler");
           }
       };
       Date startTime=new Date(System.currentTimeMillis()+10000);
       taskScheduler.scheduleAtFixedRate(task,startTime,10000);
       sleep(10000);
   }

Spring线程池方便写法

在一个方法中加上注解，它就可以在Spring线程池的环境下去运行，方法中逻辑写正常的逻辑代码,可以将此方法作为线程体而不是像上面的线程体定义一样。

Spring普通线程池简化

   //让该方法在多线程环境下，被异步的调用
   @Async
    public void executel(){
       System.out.println("executel");
   }
   //Spring线程池简化
    @Test
    public void textThreadPoolTaskExecutorSimple(){
        for(int i=0;i<10;i++){
            executel();//调用方法
            
        }
    }

Spring可执行定时任务线程池简化

    /**这个方法是自动调用,不需要调用
     * initialDelay 调用这个方法后多长时间执行
     * fixedRate 以多少频率进行执行
     */
    @Scheduled(initialDelay = 10000,fixedRate = 1000)
    public void  execute2(){
        System.out.println("execute2");
    }
    @Test
    public  void testThreadPoolTaskSchedulerSimple(){
        sleep(30000);
    }