开发中遇到这样一个需求。导出excel可能会超时。所以需要做成异步下载。因为下载线程会比较占用cpu资源，可能会有一些慢sql，所以需要控制并发数。

1.建立一个堵塞链表队列，用来存在任务；

2.收到用户请求创建一个下载任务，放在任务队列中。

3.在web.xml中设置一个监听类，启动一个线程定时扫描任务队列，当有任务时执行任务。

4.在执行任务时设置FutureTask超时时间，堵塞当前线程，当前任务一直不结束时，终止任务运行，释放资源。

代码：

  1. <listener>
  2.         <listener-class>com.taobao.kelude.k3case.listenners.ExportTaskStartupListener</listener-class>
  3. </listener>
  1. public class ExportTaskStartupListener implements ServletContextListener {
  2.     @Override
  3.     public void contextDestroyed(ServletContextEvent sce) {
  4.         sce.getServletContext().log("定时器销毁");
  5.     }
  6.     @Override
  7.     public void contextInitialized(ServletContextEvent sce) {
  8.         sce.getServletContext().log("启动线程池");
  9.         sce.getServletContext().log("启动定时器");
  10.         sce.getServletContext().log("已经添加任务调度表");
  11.         ExportTaskQueueThread exportTaskQueueThread = new ExportTaskQueueThread();
  12.         exportTaskQueueThread.start();
  13.     }
  14. }
  16. class ExportTaskQueueThread extends Thread {
  17.     public void run() {
  18.         System.out.println("init timer task");
  19.         while (true) {
  20. //            System.out.println("start timer task");
  21.             try {
  22.                 if (!ExportTaskPoolManager.queue.isEmpty()) {
  23.                     CallableTask callableTask = ExportTaskPoolManager.queue.take();
  24.                     FutureTask futureTask = new FutureTask(callableTask);
  25.                     Thread thread = new Thread(futureTask);
  26.                     thread.start();
  27.                     try {
  28.                         futureTask.get(300, TimeUnit.SECONDS);
  29.                     } catch (TimeoutException e) {
  30.                         System.out.println("export failed for timeout");
  31.                         futureTask.cancel(true);
  32.                     }
  33.                 }
  34.                 Thread.sleep(10000);
  35.             } catch (InterruptedException e) {
  36.                 e.printStackTrace();
  37.             } catch (ExecutionException e) {
  38.                 e.printStackTrace();
  39.             }
  40.         }
  41.     }
  42. }

 

  1. public class ExportTaskPoolManager {
  2. //    public static ExecutorService pool;
  3.     public static LinkedBlockingQueue<CallableTask> queue = new LinkedBlockingQueue<CallableTask>();
  4. }
  1. public class ExportCaseTask extends CallableTask {
  2.     private Logger logger = LoggerFactory.getLogger("ExportCaseTask");
  3.     private List<Integer> priority;
  4.     private Integer userId;
  5.     private Boolean needFormat;
  6.     private Integer[] suiteIds;
  7.     private List<Integer> caseIds;
  8.     private List<Integer> spaceIds;
  9.     private String name;
  10.     private String type;
  12.     public ExportCaseTask(Integer[] suiteIds, List<Integer> caseIds, List<Integer> spaceIds, String name, List<Integer> priority, String type,boolean needFormat, Integer userId) {
  13.         this.needFormat = needFormat;
  14.         this.priority = priority;
  15.         this.userId = userId;
  16.         this.suiteIds = suiteIds;
  17.         this.caseIds = caseIds;
  18.         this.spaceIds = spaceIds;
  19.         this.name = name;
  20.         this.type = type;
  21.     }
  23.     private TestCaseService testCaseService = (TestCaseService) SpringContextUtils.getBean("testCaseService");
  25.     public Object call() throws Exception {
  27.         try {
  28.             testCaseService.generateASync(suiteIds, caseIds, spaceIds, name, priority, type, needFormat, userId);
  29.             logger.info("generateASync ok");
  30.         } catch (Exception e) {
  31.             e.printStackTrace();
  32.         } finally {
  33.         }
  34.         return 1;
  35.     }
  36. }

 




版权声明：本文为myjavablog原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/myjavablog/p/5992042.html