SpringBoot开发案例之多任务并行+线程池处理

小柒2012
899 阅读8分钟
原文链接： mp.weixin.qq.com

前言

前几篇文章着重介绍了后端服务数据库和多线程并行处理优化，并示例了改造前后的伪代码逻辑。当然了，优化是无止境的，前人栽树后人乘凉。作为我们开发者来说，既然站在了巨人的肩膀上，就要写出更加优化的程序。

  • SpringBoot开发案例之JdbcTemplate批量操作

  • SpringBoot开发案例之CountDownLatch多任务并行处理

改造

理论上讲，线程越多程序可能更快，但是在实际使用中我们需要考虑到线程本身的创建以及销毁的资源消耗，以及保护操作系统本身的目的。我们通常需要将线程限制在一定的范围之类，线程池就起到了这样的作用。

程序逻辑

 一张图能解决的问题，就应该尽可能的少BB，当然底层原理性的东西还是需要大家去记忆并理解的。

Java 线程池

Java通过Executors提供四种线程池，分别为：

  • newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

  • newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

  • newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

  • newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

优点

  • 重用存在的线程，减少对象创建、消亡的开销，性能佳。

  • 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。

  • 提供定时执行、定期执行、单线程、并发数控制等功能。

代码实现

方式一(CountDownLatch)
  1. /**
  2.  * 多任务并行+线程池统计
  3.  * 创建者 科帮网  https://blog.52itstyle.com
  4.  * 创建时间    2018年4月17日
  5.  */
  6. public class StatsDemo {
  7.     final static SimpleDateFormat sdf = new SimpleDateFormat(
  8.             "yyyy-MM-dd HH:mm:ss");
  10.     final static String startTime = sdf.format(new Date());
  12.     /**
  13.      * IO密集型任务  = 一般为2*CPU核心数（常出现于线程中：数据库数据交互、文件上传下载、网络数据传输等等）
  14.      * CPU密集型任务 = 一般为CPU核心数+1（常出现于线程中：复杂算法）
  15.      * 混合型任务  = 视机器配置和复杂度自测而定
  16.      */
  17.     private static int corePoolSize = Runtime.getRuntime().availableProcessors();
  18.     /**
  19.      * public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
  20.      *                           TimeUnit unit,BlockingQueue<Runnable> workQueue)
  21.      * corePoolSize用于指定核心线程数量
  22.      * maximumPoolSize指定最大线程数
  23.      * keepAliveTime和TimeUnit指定线程空闲后的最大存活时间
  24.      * workQueue则是线程池的缓冲队列,还未执行的线程会在队列中等待
  25.      * 监控队列长度，确保队列有界
  26.      * 不当的线程池大小会使得处理速度变慢，稳定性下降，并且导致内存泄露。如果配置的线程过少，则队列会持续变大，消耗过多内存。
  27.      * 而过多的线程又会 由于频繁的上下文切换导致整个系统的速度变缓——殊途而同归。队列的长度至关重要，它必须得是有界的，这样如果线程池不堪重负了它可以暂时拒绝掉新的请求。
  28.      * ExecutorService 默认的实现是一个无界的 LinkedBlockingQueue。
  29.      */
  30.     private static ThreadPoolExecutor executor  = new ThreadPoolExecutor(corePoolSize, corePoolSize+1, 10l, TimeUnit.SECONDS,
  31.             new LinkedBlockingQueue<Runnable>(1000));
  33.     public static void main(String[] args) throws InterruptedException {
  34.         CountDownLatch latch = new CountDownLatch(5);
  35.         //使用execute方法
  36.           executor.execute(new Stats("任务A", 1000, latch));
  37.           executor.execute(new Stats("任务B", 1000, latch));
  38.           executor.execute(new Stats("任务C", 1000, latch));
  39.           executor.execute(new Stats("任务D", 1000, latch));
  40.           executor.execute(new Stats("任务E", 1000, latch));
  41.         latch.await();// 等待所有人任务结束
  42.         System.out.println("所有的统计任务执行完成:" + sdf.format(new Date()));
  43.     }
  45.     static class Stats implements Runnable  {
  46.         String statsName;
  47.         int runTime;
  48.         CountDownLatch latch;
  50.         public Stats(String statsName, int runTime, CountDownLatch latch) {
  51.             this.statsName = statsName;
  52.             this.runTime = runTime;
  53.             this.latch = latch;
  54.         }
  56.         public void run() {
  57.             try {
  58.                 System.out.println(statsName+ " do stats begin at "+ startTime);
  59.                 //模拟任务执行时间
  60.                 Thread.sleep(runTime);
  61.                 System.out.println(statsName + " do stats complete at "+ sdf.format(new Date()));
  62.                 latch.countDown();//单次任务结束，计数器减一
  63.             } catch (InterruptedException e) {
  64.                 e.printStackTrace();
  65.             }
  66.         }
  67.     }
  68. }
方式二（Future）
  1. /**
  2.  * 多任务并行+线程池统计
  3.  * 创建者 科帮网 https://blog.52itstyle.com
  4.  * 创建时间    2018年4月17日
  5.  */
  6. public class StatsDemo {
  7.     final static SimpleDateFormat sdf = new SimpleDateFormat(
  8.             "yyyy-MM-dd HH:mm:ss");
  10.     final static String startTime = sdf.format(new Date());
  12.     /**
  13.      * IO密集型任务  = 一般为2*CPU核心数（常出现于线程中：数据库数据交互、文件上传下载、网络数据传输等等）
  14.      * CPU密集型任务 = 一般为CPU核心数+1（常出现于线程中：复杂算法）
  15.      * 混合型任务  = 视机器配置和复杂度自测而定
  16.      */
  17.     private static int corePoolSize = Runtime.getRuntime().availableProcessors();
  18.     /**
  19.      * public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
  20.      *                           TimeUnit unit,BlockingQueue<Runnable> workQueue)
  21.      * corePoolSize用于指定核心线程数量
  22.      * maximumPoolSize指定最大线程数
  23.      * keepAliveTime和TimeUnit指定线程空闲后的最大存活时间
  24.      * workQueue则是线程池的缓冲队列,还未执行的线程会在队列中等待
  25.      * 监控队列长度，确保队列有界
  26.      * 不当的线程池大小会使得处理速度变慢，稳定性下降，并且导致内存泄露。如果配置的线程过少，则队列会持续变大，消耗过多内存。
  27.      * 而过多的线程又会 由于频繁的上下文切换导致整个系统的速度变缓——殊途而同归。队列的长度至关重要，它必须得是有界的，这样如果线程池不堪重负了它可以暂时拒绝掉新的请求。
  28.      * ExecutorService 默认的实现是一个无界的 LinkedBlockingQueue。
  29.      */
  30.     private static ThreadPoolExecutor executor  = new ThreadPoolExecutor(corePoolSize, corePoolSize+1, 10l, TimeUnit.SECONDS,
  31.             new LinkedBlockingQueue<Runnable>(1000));
  33.     public static void main(String[] args) throws InterruptedException {
  34.         List<Future<String>> resultList = new ArrayList<Future<String>>(); 
  35.         //使用submit提交异步任务，并且获取返回值为future
  36.         resultList.add(executor.submit(new Stats("任务A", 1000)));
  37.         resultList.add(executor.submit(new Stats("任务B", 1000)));
  38.         resultList.add(executor.submit(new Stats("任务C", 1000)));
  39.         resultList.add(executor.submit(new Stats("任务D", 1000)));
  40.         resultList.add(executor.submit(new Stats("任务E", 1000)));
  41.          //遍历任务的结果
  42.         for (Future<String> fs : resultList) { 
  43.             try { 
  44.                 System.out.println(fs.get());//打印各个线任务执行的结果，调用future.get() 阻塞主线程，获取异步任务的返回结果
  45.             } catch (InterruptedException e) { 
  46.                 e.printStackTrace(); 
  47.             } catch (ExecutionException e) { 
  48.                 e.printStackTrace(); 
  49.             } finally { 
  50.                 //启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
  51.                 executor.shutdown(); 
  52.             } 
  53.         } 
  54.         System.out.println("所有的统计任务执行完成:" + sdf.format(new Date()));
  55.     }
  57.     static class Stats implements Callable<String>  {
  58.         String statsName;
  59.         int runTime;
  61.         public Stats(String statsName, int runTime) {
  62.             this.statsName = statsName;
  63.             this.runTime = runTime;
  64.         }
  66.         public String call() {
  67.             try {
  68.                 System.out.println(statsName+ " do stats begin at "+ startTime);
  69.                 //模拟任务执行时间
  70.                 Thread.sleep(runTime);
  71.                 System.out.println(statsName + " do stats complete at "+ sdf.format(new Date()));
  72.             } catch (InterruptedException e) {
  73.                 e.printStackTrace();
  74.             }
  75.             return call();
  76.         }
  77.     }
  78. }

执行时间

以上代码，均是伪代码，下面是2000+个学生的真实测试记录。

  1. 2018-04-17 17:42:29.284 INFO   测试记录81e51ab031eb4ada92743ddf66528d82-单线程顺序执行，花费时间:3797
  2. 2018-04-17 17:42:31.452 INFO   测试记录81e51ab031eb4ada92743ddf66528d82-多线程并行任务，花费时间:2167
  3. 2018-04-17 17:42:33.170 INFO   测试记录81e51ab031eb4ada92743ddf66528d82-多线程并行任务+线程池，花费时间:1717

avatar
文章
阅读
粉丝