spring动态线程池(实质还是用了java的线程池)

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

  <!-- 异步线程池 -->  
  <bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">  
    <!-- 核心线程数  -->  
    <property name="corePoolSize" value="8" />  
    <!-- 最大线程数 -->  
    <property name="maxPoolSize" value="100" />  
    <!-- 队列最大长度 >=mainExecutor.maxSize -->  
    <property name="queueCapacity" value="0" />  
    <!-- 线程池维护线程所允许的空闲时间 -->  
    <property name="keepAliveSeconds" value="500" />  
    <!-- 线程池对拒绝任务(无线程可用)的处理策略 -->  
    <property name="rejectedExecutionHandler">  
      <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />  
    </property>  
  </bean>  

</beans>

public class MyCallable implements Callable<String> {
    private String name; 
    public MyCallable(String name){ 
        this.name=name;
    }
    @Override
    public String call() throws Exception {
        Thread.sleep(5000);
        return name;
    }
}

import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

public class threadPoolTest {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        ThreadPoolTaskExecutor taskExecutor = (ThreadPoolTaskExecutor) ctx.getBean("taskExecutor");
        CompletionService<String> cs = new ExecutorCompletionService<>(taskExecutor);
        for (int i = 0; i < 5; i++) {
            cs.submit(new MyCallable("Thread "+i));
        }
        for (int i = 0; i < 5; i++){
             try {
                System.out.println(cs.take().get());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }  
        }

    }
}

 

public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext1.xml");
        ThreadPoolTaskExecutor taskExecutor = (ThreadPoolTaskExecutor) ctx.getBean("taskExecutor");
        List<Future<String>> list = new ArrayList<Future<String>>(); 
        
        for (int i = 0; i < 5; i++) {
            Future<String> future=    taskExecutor.submit(new MyCallable("Thread "+i));
            list.add(future);
        }
        for (Iterator iterator = list.iterator(); iterator.hasNext();) {
            Future<String> future = (Future<String>) iterator.next();
            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            iterator.remove();
        }
        System.out.println(list.size());
    }

queueCapacity参数是0的话，用的是SynchronousQueue，否则是LinkedBlockingQueue。
用CallerRunsPolicy策略的话，线程超过最大数量和队列长度之和，主线程等待，直到线程池有空闲线程。

转载于:https://www.cnblogs.com/tonggc1668/p/7280738.html