记一次没使用线程池挨批往事

事情是这样的，之前公司项目的一个功能涉及到查询大数据量统计操作，因为大数据量统计操作需要的时间比较长，如果在业务中同步操作该统计操作的话，耗时长，将对用户体验很差，所以呢就需要异步开启多一个线程去执行该统计操作了，这里有两种方案，一种是使用多线程，一种是使用消息队列，我选择的是使用多线程，
类似代码如下：

Thread thread=new Thread(new Runnable() {
		@Override
		public void run() {
			doXXX(a1,a2);	
		}
	});

看起来没啥毛病，多数人也是会那么写的，临近下班的时候，组长找我过去谈话，他刚好看了我今天提交的代码，发现了我这一块代码，就问我为什么有线程池不用，偏偏要重新开多一个线程。频繁的创建一个线程会过多消耗CPU的资源，如果可运行的线程数量多于可用处理起的数量，那么有线程将会被闲置，大量空闲的线程会占用许多内存，给垃圾回收器带来压力，而且大量的线程在竞争CPU资源时还将产生其他性能的开销。
认识到错误后，自然是要改代码的了,在此也想把自定义线程池的使用方法记录一下。
yml配置:

threadPool:  
###核心线程数
   corePoolSize: 10
 ###最大线程数  
   maxPoolSize: 20
 ##  队列容量
   queueCapacity: 16  

配置文件：

package com.youth.pay.config;

import java.lang.reflect.Method;
import java.util.concurrent.Executor;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import lombok.extern.slf4j.Slf4j;

/**
 * 
 * springboot 整合线程池
 * 
 * @description:
 * @author: lzy
 */
@Configuration
@EnableAsync
@Slf4j
public class AsyncTaskConfig implements AsyncConfigurer {

	/**
	 * 最小线程数(核心线程数)
	 */
	@Value("${threadPool.corePoolSize}")
	private int corePoolSize;
	/**
	 * 最大线程数
	 */
	@Value("${threadPool.maxPoolSize}")
	private int maxPoolSize;
	/**
	 * 等待队列(队列最大长度)
	 */
	@Value("${threadPool.queueCapacity}")
	private int queueCapacity;

	/**
	 * ThredPoolTaskExcutor的处理流程 当池子大小小于corePoolSize，就新建线程，并处理请求
	 * 当池子大小等于corePoolSize，把请求放入workQueue中，池子里的空闲线程就去workQueue中取任务并处理
	 * 当workQueue放不下任务时，就新建线程入池，并处理请求，如果池子大小撑到了maximumPoolSize，
	 * 就用RejectedExecutionHandler来做拒绝处理
	 * 当池子的线程数大于corePoolSize时，多余的线程会等待keepAliveTime长时间，如果无请求可处理就自行销毁
	 */
	@Override
	@Bean(name = "taskExecutor")
	public Executor getAsyncExecutor() {
		ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
		// 最小线程数(核心线程数)
		taskExecutor.setCorePoolSize(corePoolSize);
		// 最大线程数
		taskExecutor.setMaxPoolSize(maxPoolSize);
		// 等待队列(队列最大长度)
		taskExecutor.setQueueCapacity(queueCapacity);
		taskExecutor.initialize();
		return taskExecutor;
	}

	/**
	 * 异步异常处理
	 * 
	 * @return
	 */
	@Override
	public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
		return new SpringAsyncExceptionHandler();
	}

	class SpringAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
		@Override
		public void handleUncaughtException(Throwable throwable, Method method, Object... obj) {
			log.error("Exception occurs in async method", throwable.getMessage());
		}

	}
}

类似业务代码：

@Autowired
private ThreadPoolTaskExecutor threadPoolTaskExecutor;

public void updateConfig(Entity entity){
	--此处忽略n行代码
	threadPoolTaskExecutor.execute(new doXXXThread(a1, a2));
	--此处忽略n行代码
}


class doXXXThread implements Runnable {
	private String a1;
	private Map<String, String> a2;
		

	public PayLogThread(String a1, Map<String, String> a2) {
		this.a1 = a1;
		this.a2 = a2;
	}

	@Override
	public  void run() {
	      doXXX(a1, a2);
	}
}

看到此处，可能很多人都会觉得怎么感觉变成那么复杂了啊，还不如像我之前那样自己开一个线程来执行业务代码呢，哈哈哈，那这就是你拿6K工资跟别人能拿30K工资的区别了。接下来我将浅谈下线程池的创建方式以及线程池的处理流程，想了解具体原理的可自行百度，一堆。
Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
使用方式如下

//可以缓存的线程池
ExecutorService newCachedThreadPool= Executors.newCachedThreadPool();
		for (int i = 0; i < 30; i++) {
			final int temp=i;
			newCachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println(Thread.currentThread().getName()+":"+temp);
					} catch (Exception e) {
						// TODO: handle exception
					}
				}
			});
		}
		
//可定长线程
ExecutorService newFixedThreadPool= Executors.newFixedThreadPool(3);
		for (int i = 0; i < 30; i++) {
			final int temp=i;
			newFixedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					try {
						System.out.println(Thread.currentThread().getName()+":"+temp);
					} catch (Exception e) {
						// TODO: handle exception
					}
				}
			});
		}

// 可以定时线程池
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(3);
		for (int i = 0; i < 10; i++) {
			final int temp = i;
			newScheduledThreadPool.schedule(new Runnable() {
				public void run() {
					System.out.println(Thread.currentThread().getName()+",i:" + temp);
				}
			}, 3, TimeUnit.SECONDS);
		}
		
//单线程池
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
		for (int i = 0; i < 10; i++) {
			final int temp = i;
			newSingleThreadExecutor.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getName() + ",i:" + temp);
				}
			});
		}

线程池的处理流程:
1.判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者核心线程没有被创建），则创建一个新的工作线程来执行任务，如果核心线程都在执行任务，则进入下个流程。
2.线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里，如果工作队列满了，则进入下个流程。
3.判断线程池里的线程是否都处于工作状态（判断是否超过最大线程数），如果没有，则创建一个新的工作线程来执行任务，如果已经满了，则交给饱和策略来处理这个任务。