ThreadPoolTaskExecutor

<bean id="threadPoolTaskExecutor"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 核心线程数，默认为1 -->
        <property name="corePoolSize" value="10" />
        <!-- 最大线程数，默认为Integer.MAX_VALUE -->
        <property name="maxPoolSize" value="50" />
        <!-- 队列最大长度，一般需要设置值>=notifyScheduledMainExecutor.maxNum；默认为Integer.MAX_VALUE-->
		<property name="queueCapacity" value="2000" />
        <!-- 线程池维护线程所允许的空闲时间，默认为60s -->
        <property name="keepAliveSeconds" value="300" />
        <!-- 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者 -->
        <property name="rejectedExecutionHandler">
            <!-- AbortPolicy:直接抛出java.util.concurrent.RejectedExecutionException异常 -->
            <!-- CallerRunsPolicy:主线程直接执行该任务，执行完之后尝试添加下一个任务到线程池中，可以有效降低向线程池内添加任务的速度 -->
            <!-- DiscardOldestPolicy:抛弃旧的任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
            <!-- DiscardPolicy:抛弃当前任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
            <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
        </property>
    </bean>

package com.test.controller;

public class SpringThread extends Thread{

	
    private int paramter;
    
    public SpringThread(int paramter){
        this.paramter=paramter;
    }

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"执行了"+paramter);
        return null;
    }
}

package com.test.controller;


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Controller;

import com.test.utils.SpringConfigTool;

@Controller
public class Test extends Object{
 
	/*@RequestMapping("/test.do")
	public String get(){
		System.out.println(11);
		String secretKey = (String) CustomPropertyConfig.getContextProperty("secretKey");
		System.out.println(secretKey);
		return "index";
	}*/
	
	
	 public static void main(String[] args) throws Exception {
            ApplicationContext appContext = new ClassPathXmlApplicationContext("context/springmvc.xml");
           ThreadPoolTaskExecutor  exe = (ThreadPoolTaskExecutor ) appContext.getBean("threadPoolTaskExecutor");
           for (int i = 0; i < 1000; i++) {
             FutureTask<String> task = new FutureTask<String>(new SpringThread(i));
             exe.execute(task);
          }
	}
	 
	 
	 
	 
	 
  
}

线程池的应用场景

Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处：

降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

线程池的实现原理

ThreadPoolExecutor

ThreadPoolExecutor执行execute方法分下面4种情况：

如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）。

如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。

如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务（注意：执行这一步骤需要获取全局锁）。

如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。