java 用线程异步导出excel

àì夳堔傛蜴生んèń 2021-10-15 21:31 1328阅读 0赞

# 一、前言 #

现在用的比较多的都是用POI技术来导出Excel，对于导出数据量不大的直接用POI技术按部就班实现即可，但是对于数据量大且需要导出的数据封装业务较复杂，单纯的用POI技术实现在高并发导出数据量较大时就会出现应用程序内存溢出，为了解决此问题，以下通过用线程池异步导出的方式实现。

# 二、线程池 #

从Java线程池ThreadPoolExecutor提供了四个构造方法中了解到，在如下场景的的时候，就需要我们使用自定ThreadPoolExecutor和BlockingQueue队列结合使用来处理。

1、需要的子线程数量很多，但是数量不确定。  
2、子线程有自己的优先级，根据优先级来确定执行的先后顺序。  
3、监听线程池的开始，结束，关闭等状态。  
ThreadPoolExecutor构造方法之四如下：

//使用给定的初始参数创建一个新的ThreadPoolExecutor
    public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler)

**主要参数**

*  corePoolSize：核心线程数

核心线程会一直存活，及时没有任务需要执行。当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理。

*  maxPoolSize：最大线程数

当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务。  
       当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常。

*  keepAliveTime：非核心线程闲置时的超时时长

超过这个时长，非核心线程就会被回收。当ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true 时，keepAliveTime 同样        会作用于核心线程。

*  unit：用于指定 keepAliveTime 参数的时间单位

常用的有 TimeUnit .MILLISECONDS 和 TimeUnit .SECONDS。

*  workQueue：线程池中的任务队列

通过线程池的 execute 方法提交的 Runnable 对象会存储在这个参数中。

*  threadFactory：线程工厂

为线程池提供创建新的线程的功能。threadFactory 是一个接口，它只有一个方法: public abstract Thread newThread (Runnable r);

*  RejectedExecutionHandler：通常叫做拒绝策略

在线程池已经关闭的情况下或者当线程数已经达到maxPoolSize且队列已满。只要满足其中一种时，在使用execute() 来提交新的任务         时将会拒绝，而默认的拒绝策略是抛一个 RejectedExecutionException 异常。

# 三、执行说明 #

提交一个新任务到线程池时首先线程池判断基本线程池(corePoolSize)是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程；其次线程池判断工作队列(workQueue)是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程；最后线程池判断整个线程池(maximumPoolSize)是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务；如果线程池中的线程数量大于 corePoolSize 时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过 keepAliveTime，线程也会被终止。

# 四、关键程序代码 #

public void createThreadExcel(final Vo vo,
    			final Long exportExcelId,final String fileName,final NosCurrentUser userInfo) {
    		Runnable runnable = new Runnable(){
    			@Override
    			public void run() {
                                    //具体的业务（用分页查询出数据，先生成EXCEL文件，再保存到文件服务端且生成一个文件路径，前端直接下载）
    				ExportExcel exportExcel = createExcel(vo,fileName,userInfo);
    			}};
                             //注意：使用单例模式
    			ExportQueuePoolService.getInstance().put(runnable);
    	}

package cn.uce.nos.common.util.threadPool;
    
    public class ExportQueuePoolService{
    	BlockThreadPool pool=null;
    	private ThreadCounter() {
    		pool = new BlockThreadPool(3);
    	}
    
    	public static ExportQueuePoolServiceinstance = null;
    	public static ExportQueuePoolServicegetInstance() {
    		if (instance == null) {
    			synchronized (ExportQueuePoolService.class) {
    				if (instance == null) {
    					instance = new ExportQueuePoolService();
    				}
    			}
    		}
    		return instance;
    	}
    
    	public void put(Runnable service){
    		pool.execute(service);
    	}
    
    }

package cn.uce.nos.common.util.threadPool;
    
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.RejectedExecutionHandler;
    import java.util.concurrent.ThreadFactory;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class BlockThreadPool {
    	  private ThreadPoolExecutor pool = null;
    	    
    	    public BlockThreadPool(int poolSize) {
    	        pool = new ThreadPoolExecutor(poolSize, 
    	        		2, 
    	        		0, 
    	        		TimeUnit.MILLISECONDS,
    	        		new ArrayBlockingQueue<Runnable>(80), 
    	        		new CustomThreadFactory(),
    	                new CustomRejectedExecutionHandler());
    	    }
    	    
    	    public void destory() {
    	        if (pool != null) {
    	            pool.shutdownNow();
    	        }
    	    }
    
    	    private class CustomThreadFactory implements ThreadFactory {
    	        private AtomicInteger count = new AtomicInteger(0);
    	        @Override
    	        public Thread newThread(Runnable r) {
    	            Thread t = new Thread(r);
    	            String threadName = BlockThreadPool.class.getSimpleName() + count.addAndGet(1);
    	            t.setName(threadName);
    	            return t;
    	        }
    	    }
    
    	    private class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    	        @Override
    	        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
    	            try {
    	                // 核心改造点，由blockingqueue的offer改成put阻塞方法
    	                System.out.println("r-size-befor===="+executor.getQueue().size());
    	                executor.getQueue().put(r);
    	                System.out.println("r-size-end===="+executor.getQueue().size());
    	            } catch (InterruptedException e) {
    	                e.printStackTrace();
    	            }
    	        }
    	    }
    
    	    public void execute(Runnable runnable) {
    	        this.pool.execute(runnable);
    	    }
    
    }

# 五、引用相关文章 #

1、[Java并发ThreadPoolExecutor+BlockingQueue使用详解][Java_ThreadPoolExecutor_BlockingQueue]

2、[线程池之ThreadPoolExecutor使用][ThreadPoolExecutor]

[Java_ThreadPoolExecutor_BlockingQueue]: https://blog.csdn.net/DeMonliuhui/article/details/86477888
[ThreadPoolExecutor]: https://www.jianshu.com/p/f030aa5d7a28