public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);//核心線程大小
        executor.setMaxPoolSize(2);//最大線程大小
        executor.setQueueCapacity(500);//d隊(duì)列最大容量
   executor.setThreadNamePrefix("Gith");
         executor.setKeepAliveSeconds(3000);//最大存活 時(shí)間
        executor.initialize();
        executor.submit(new ThreadDemo());
        return executor;
    }

CorePoolSize 核心線程大小
keepAliveSeconds 線程池所能允許的空閑時(shí)間
maxPoolSize 線程池維護(hù)線程的最大數(shù)量
queueCapacity 線程池所能使用的緩沖隊(duì)列

當(dāng)一個(gè)任務(wù)通過execute(方法，欲加到線程池中時(shí)；)
1 如果此時(shí)線程池中的數(shù)量小于corePoolSize，即使線程池中的線程都處于空閑狀態(tài)，也要?jiǎng)?chuàng)建新的線程來處理被添加的任務(wù)。

2，如果線程池中的數(shù)量等于corePoolsize，緩沖隊(duì)列workQueue未滿，那么任務(wù)被放入緩沖隊(duì)列
3，如果此時(shí)線程池中的數(shù)量大于coreSize,緩沖隊(duì)列workQueue滿，并且線程池的數(shù)量小于maximumPoolSize,建立新的線程來處理被添加的任務(wù)。

4 如果此時(shí)線程池中的數(shù)量大于corePoolSize,緩沖隊(duì)列workQueue滿，并且線程池中的數(shù)量等于maximumPoolSize，那么通過handler所指定的策略來處理任務(wù)。也就是：處理任務(wù)的優(yōu)先級(jí)為: 核心線程corePoolSize, 任務(wù)隊(duì)列workQueue,最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務(wù)。

5，當(dāng)線程池中的線程數(shù)量大于corePoolSize 時(shí)，如果某線程空閑時(shí)間超過keepAliveTime，線程將被終止。這樣，線程池可以動(dòng)態(tài)的調(diào)整池中的線程數(shù)。

package ch2.taskexecutor;
 
 
//執(zhí)行器
import java.util.concurrent.Executor;
//異步捕獲助手
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ComponentScan;
 
//配置
import org.springframework.scheduling.annotation.AsyncConfigurer;
//異步支持注解
import org.springframework.scheduling.annotation.EnableAsync;
//線程池
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 
//聲明這是一個(gè)配置類
@Configuration
//引入ch2.taskexecutor下面的@service,@component,@repository,@controller注冊(cè)為bean
@ComponentScan("ch2.taskexecutor")
//開啟注解：開啟異步支持
@EnableAsync
 
//配置類實(shí)現(xiàn)AsyncConfigurer接口并重寫AsyncConfigurer方法，并返回一個(gè)ThreadPoolTaskExecutor
//這樣我們就得到了一個(gè)基于線程池的TaskExecutor
public class TaskExecutorConfig implements AsyncConfigurer {
 
     
    //配置類實(shí)現(xiàn)AsyncConfigurer接口并重寫AsyncConfigurer方法，并返回一個(gè)ThreadPoolTaskExecutor
    //這樣我們就得到了一個(gè)基于線程池的TaskExecutor
    @Override
    public Executor getAsyncExecutor() {
        // TODO Auto-generated method stub
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //如果池中的實(shí)際線程數(shù)小于corePoolSize,無論是否其中有空閑的線程，都會(huì)給新的任務(wù)產(chǎn)生新的線程
        taskExecutor.setCorePoolSize(5);
        //連接池中保留的最大連接數(shù)。Default: 15 maxPoolSize  
        taskExecutor.setMaxPoolSize(10);
        //queueCapacity 線程池所使用的緩沖隊(duì)列
        taskExecutor.setQueueCapacity(25);
        taskExecutor.initialize();
        return taskExecutor;
    }
 
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        // TODO Auto-generated method stub
        return null;
    }
     
 
}

package ch2.taskexecutor;
//組件聲明類
import org.springframework.stereotype.Service;
//異步聲明,如果在方法表示是異步方法，如果在類表示異步類。
//這里的方法自動(dòng)被注入使用ThreadPoolTaskExecutor作為TaskExecutor（線程池）
import org.springframework.scheduling.annotation.Async;
 
//聲明為組件
@Service
public class AsyncService {
 
     
    //異步聲明,如果在方法處表示是異步方法，如果在類處表示異步類（所有的方法都是異步方法）。
    //這里的方法自動(dòng)被注入使用ThreadPoolTaskExecutor作為TaskExecutor（線程池）
    @Async
    public void executorAsyncTask(Integer i)
    {
        System.out.println("執(zhí)行異步：" + i);
    }
     
     
    //異步聲明,如果在方法處表示是異步方法，如果在類處表示異步類（所有的方法都是異步方法）。
    //這里的方法自動(dòng)被注入使用ThreadPoolTaskExecutor作為TaskExecutor（線程池）
    @Async
    public void executorAsyncTaskPlus(Integer i)
    {
        System.out.println("執(zhí)行異步任務(wù)+1: " + (i+1));
    }
     
}

package ch2.taskexecutor;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 
public class Main {
 
     
    public static void main(String[] args)
    {
         
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TaskExecutorConfig.class);
        AsyncService asyncService = context.getBean(AsyncService.class);
         
        for(int i = 0; i<10; i++)
        {
            asyncService.executorAsyncTask(i);
            asyncService.executorAsyncTaskPlus(i);
        }
         
        context.close();
         
    }
     
}

運(yùn)行

執(zhí)行異步：0
執(zhí)行異步任務(wù)+1: 1
執(zhí)行異步任務(wù)+1: 3
執(zhí)行異步：3
執(zhí)行異步任務(wù)+1: 4
執(zhí)行異步任務(wù)+1: 5
執(zhí)行異步：2
執(zhí)行異步：4
執(zhí)行異步任務(wù)+1: 6
執(zhí)行異步：5
執(zhí)行異步：1
執(zhí)行異步任務(wù)+1: 2
執(zhí)行異步任務(wù)+1: 8
執(zhí)行異步：7
執(zhí)行異步任務(wù)+1: 9
執(zhí)行異步任務(wù)+1: 7
執(zhí)行異步任務(wù)+1: 10
執(zhí)行異步：6
執(zhí)行異步：9
執(zhí)行異步：8