007-多线程-JUC线程池-Spring线程池配置

    <!-- Spring线程池 -->
    <bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 核心线程数 -->
        <property name="corePoolSize" value="5" />
        <!-- 线程池维护线程的最大数量 -->
        <property name="maxPoolSize" value="10" />
        <!-- 允许的空闲时间, 默认60秒 -->
        <property name="keepAliveSeconds" value="60" />
        <!-- 任务队列 -->
        <property name="queueCapacity" value="50" />
        <!-- 线程超过空闲时间限制，均会退出直到线程数量为0 -->
        <property name="allowCoreThreadTimeOut" value="true"/>
        <!-- 对拒绝task的处理策略 -->
        <property name="rejectedExecutionHandler">
            <bean class="java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy" />
        </property>
    </bean>

//帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringThreadPoolExecutorTest {

    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    @Test
    public void newFixedThreadPoolTestSubmit() throws Exception {
        List<Future<?>> list=new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            Future<?> submit = taskExecutor.submit(new DataTask("ssss" + i));
            list.add(submit);
        }
        for (Future<?> future : list) {
            future.get();
        }
    }

    class DataTask implements Runnable {
        private String a;

        public DataTask(String a) {
            this.a = a;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("-------"+ LocalDateTime.now()+a);
        }
    }
}

当一个新任务来临时：
1）如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务；
2）如果此时线程池中的数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务被放入缓冲队列；
3）如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maxPoolSize，建新的线程来处理被添加的任务；
4）如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maxPoolSize，那么通过handler所指定的策略来处理此任务；
5）当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，如果allowCoreThreadTimeOut为false，则线程数量维持在corePoolSize， 如果为true，则线程数量可最低降至0；

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:task="http://www.springframework.org/schema/task"
           xsi:schemaLocation=
                   "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                   http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

     <!-- 包路径扫描 -->
    <context:component-scan base-package="spring.task"/>

    <!-- 定义线程池 -->
    <task:executor id="executor" pool-size="5" queue-capacity="10" rejection-policy="DISCARD_OLDEST"/>

</beans>

@Component
public class AsyncTask {

    @Autowired
    private ThreadPoolTaskExecutor executor;

    @PostConstruct
    public void testAsycTask() {
        for (int i = 0; i < 10; i++) {
            executor.execute(new Runnable() {
                public void run() {
                    asyncTask();
                }
            });
        }
    }

private void asyncTask(){
        System.out.println( "---" + Thread.currentThread().getName());
    }   
}