springboot之初始化通用线程池

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
* @description : 通用线程池,用于异步执行写操作不影响主线程
*/
@Configuration
@EnableAsync
public class InitThread {

    //线程池维护线程的最少数量
    private static final int CORE_POOL_SIZE = 10;

    //线程池维护线程的最大数量
    private static final int MAX_POOL_SIZE = 50;

    //缓存队列
    private static final int QUEUE_CAPACITY = 10;

    //允许的空闲时间
    private static final int KEEP_ALIVE = 60;

    @Bean
    public Executor myExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(CORE_POOL_SIZE);
        executor.setMaxPoolSize(MAX_POOL_SIZE);
        executor.setQueueCapacity(QUEUE_CAPACITY);
        executor.setThreadNamePrefix("executor-");
        /*
         *  使用此策略，如果添加到线程池失败，那么主线程会自己去执行该任务，不会等待线程池中的线程去执行
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setKeepAliveSeconds(KEEP_ALIVE);
        executor.initialize();
        return executor;
    }

}

拒绝策略RejectedExecutionHandler

AbortPolicy：该策略是线程池的默认策略。使用该策略时，如果线程池队列满了丢掉这个任务并且抛出RejectedExecutionException异常
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
            //不做任何处理，直接抛出异常  
            throw new RejectedExecutionException("Task" + r.toString() +  
                                                 " rejected from " +  
                                                 e.toString());  
}

DiscardPolicy ：这个策略和AbortPolicy的slient版本，如果线程池队列满了，会直接丢掉这个任务并且不会有任何异常。 
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
         //就是一个空的方法  
      }  

DiscardOldestPolicy ：这个策略从字面上也很好理解，丢弃最老的。也就是说如果队列满了，会将最早进入队列的任务删掉腾出空间，再尝试加入队列。 
因为队列是队尾进，队头出，所以队头元素是最老的，因此每次都是移除对头元素后再尝试入队。
 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
     if (!e.isShutdown()) {  
         //移除队头元素  
         e.getQueue().poll();  
         //再尝试入队  
         e.execute(r);  
     }  
 }

CallerRunsPolicy ：使用此策略，如果添加到线程池失败，那么主线程会自己去执行该任务，不会等待线程池中的线程去执行。就像是个急脾气的人，我等不到别人来做这件事就干脆自己干。
 public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
             if (!e.isShutdown()) {  
                 //直接执行run方法  
                 r.run();  
             }  
         }


自定义：只要实现RejectedExecutionHandler接口，并且实现rejectedExecution方法就可以了。具体的逻辑就在rejectedExecution方法里去定义就OK了
 public class MyRejectPolicy implements RejectedExecutionHandler{  
     public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {  
         //Sender是我的Runnable类，里面有message字段  
         if (r instanceof Sender) {  
             Sender sender = (Sender) r;  
             //直接打印  
             System.out.println(sender.getMessage());  
         }  
     }  
 } 

 

转载于:https://my.oschina.net/u/3020519/blog/3072278