你破坏Java代码的样子，真美！

本文转载自微信公众号「小明菜市场」，作者小明菜市场。转载本文请联系小明菜市场公众号。

在慈溪等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站建设、网站设计 网站设计制作按需网站策划,公司网站建设,企业网站建设,成都品牌网站建设,网络营销推广,外贸网站建设,慈溪网站建设费用合理。

前言

在之前如果需要处理集合需要先手动分成几部分，然后为每部分创建线程，最后在合适的时候合并，这是手动处理并行集合的方法，在java8中，有了新功能，可以一下开启并行模式。

并行流

认识开启并行流

并行流是什么?是把一个流内容分成多个数据块，并用不同线程分别处理每个不同数据块的流。例如，有下面一个例子，在List中，需要对List数据进行分别计算，其代码如下所示：

 
 
 
    
  
  
  
  1. List appleList = new ArrayList<>(); // 假装数据是从库里查出来的 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. for (Apple apple : appleList) { 
    4. 
  
  
  
  4.     apple.setPrice(5.0 * apple.getWeight() / 1000); 
    5. 
  
  
  
  5. } 
    6.

在这里，时间复杂度为O(list.size)，随着list的增加，耗时也在增加。并行流可以解决这个问题，代码如下所示：

appleList.parallelStream().forEach(apple -> apple.setPrice(5.0 * apple.getWeight() / 1000));

这里通过调parallelStream()说明当前流为并行流，然后进行并行执行。并行流内部使用了默认的ForkJoinPool线程池，默认线程数为处理器的核心数。

测试并行流

普通代码如下所示：

 
 
 
    
  
  
  
  1. public static void main(String[] args) throws InterruptedException { 
    2. 
  
  
  
  2.     List appleList = initAppleList(); 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     Date begin = new Date(); 
    5. 
  
  
  
  5.     for (Apple apple : appleList) { 
    6. 
  
  
  
  6.         apple.setPrice(5.0 * apple.getWeight() / 1000); 
    7. 
  
  
  
  7.         Thread.sleep(1000); 
    8. 
  
  
  
  8.     } 
    9. 
  
  
  
  9.     Date end = new Date(); 
    10. 
  
  
  
  10.     log.info("苹果数量：{}个, 耗时：{}s", appleList.size(), (end.getTime() - begin.getTime()) /1000); 
    11. 
  
  
  
  11. } 
    12.

输出的内容为耗时4s。

并行代码如下所示：

 
 
 
    
  
  
  
  1. List appleList = initAppleList(); 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. Date begin = new Date(); 
    4. 
  
  
  
  4. appleList.parallelStream().forEach(apple -> 
    5. 
  
  
  
  5.                                    { 
    6. 
  
  
  
  6.                                        apple.setPrice(5.0 * apple.getWeight() / 1000); 
    7. 
  
  
  
  7.                                        try { 
    8. 
  
  
  
  8.                                            Thread.sleep(1000); 
    9. 
  
  
  
  9.                                        } catch (InterruptedException e) { 
    10. 
  
  
  
  10.                                            e.printStackTrace(); 
    11. 
  
  
  
  11.                                        } 
    12. 
  
  
  
  12.                                    } 
    13. 
  
  
  
  13.                                   ); 
    14. 
  
  
  
  14. Date end = new Date(); 
    15. 
  
  
  
  15. log.info("苹果数量：{}个, 耗时：{}s", appleList.size(), (end.getTime() - begin.getTime()) /1000); 
    16.

输出结果为耗时1s。可以看到耗时大大提升了3s。

并行流拆分会影响流的速度

对于并行流来说需要注意以下几点：

  1. 对于 iterate 方法来处理的前 n 个数字来说，不管并行与否，它总是慢于循环的，
  2. 而对于 LongStream.rangeClosed() 方法来说，就不存在 iterate 的第两个痛点了。它生成的是基本类型的值，不用拆装箱操作，另外它可以直接将要生成的数字 1 - n 拆分成 1 - n/4， 1n/4 - 2n/4， ... 3n/4 - n 这样四部分。因此并行状态下的 rangeClosed() 是快于 for 循环外部迭代的

代码如下所示：

 
 
 
    
  
  
  
  1. package lambdasinaction.chap7; 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. import java.util.stream.*; 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5. public class ParallelStreams { 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.     public static long iterativeSum(long n) { 
    8. 
  
  
  
  8.         long result = 0; 
    9. 
  
  
  
  9.         for (long i = 0; i <= n; i++) { 
    10. 
  
  
  
  10.             result += i; 
    11. 
  
  
  
  11.         } 
    12. 
  
  
  
  12.         return result; 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15.     public static long sequentialSum(long n) { 
    16. 
  
  
  
  16.         return Stream.iterate(1L, i -> i + 1).limit(n).reduce(Long::sum).get(); 
    17. 
  
  
  
  17.     } 
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.     public static long parallelSum(long n) { 
    20. 
  
  
  
  20.         return Stream.iterate(1L, i -> i + 1).limit(n).parallel().reduce(Long::sum).get(); 
    21. 
  
  
  
  21.     } 
    22. 
  
  
  
  22.  
    23. 
  
  
  
  23.     public static long rangedSum(long n) { 
    24. 
  
  
  
  24.         return LongStream.rangeClosed(1, n).reduce(Long::sum).getAsLong(); 
    25. 
  
  
  
  25.     } 
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27.     public static long parallelRangedSum(long n) { 
    28. 
  
  
  
  28.         return LongStream.rangeClosed(1, n).parallel().reduce(Long::sum).getAsLong(); 
    29. 
  
  
  
  29.     } 
    30. 
  
  
  
  30.  
    31. 
  
  
  
  31. } 
    32. 
  
  
  
  32. package lambdasinaction.chap7; 
    33. 
  
  
  
  33.  
    34. 
  
  
  
  34. import java.util.concurrent.*; 
    35. 
  
  
  
  35. import java.util.function.*; 
    36. 
  
  
  
  36.  
    37. 
  
  
  
  37. public class ParallelStreamsHarness { 
    38. 
  
  
  
  38.  
    39. 
  
  
  
  39.     public static final ForkJoinPool FORK_JOIN_POOL = new ForkJoinPool(); 
    40. 
  
  
  
  40.  
    41. 
  
  
  
  41.     public static void main(String[] args) { 
    42. 
  
  
  
  42.         System.out.println("Iterative Sum done in: " + measurePerf(ParallelStreams::iterativeSum, 10_000_000L) + " msecs"); 
    43. 
  
  
  
  43.         System.out.println("Sequential Sum done in: " + measurePerf(ParallelStreams::sequentialSum, 10_000_000L) + " msecs"); 
    44. 
  
  
  
  44.         System.out.println("Parallel forkJoinSum done in: " + measurePerf(ParallelStreams::parallelSum, 10_000_000L) + " msecs" ); 
    45. 
  
  
  
  45.         System.out.println("Range forkJoinSum done in: " + measurePerf(ParallelStreams::rangedSum, 10_000_000L) + " msecs"); 
    46. 
  
  
  
  46.         System.out.println("Parallel range forkJoinSum done in: " + measurePerf(ParallelStreams::parallelRangedSum, 10_000_000L) + " msecs" ); 
    47. 
  
  
  
  47.     } 
    48. 
  
  
  
  48.  
    49. 
  
  
  
  49.     public static  long measurePerf(Function f, T input) { 
    50. 
  
  
  
  50.         long fastest = Long.MAX_VALUE; 
    51. 
  
  
  
  51.         for (int i = 0; i < 10; i++) { 
    52. 
  
  
  
  52.             long start = System.nanoTime(); 
    53. 
  
  
  
  53.             R result = f.apply(input); 
    54. 
  
  
  
  54.             long duration = (System.nanoTime() - start) / 1_000_000; 
    55. 
  
  
  
  55.             System.out.println("Result: " + result); 
    56. 
  
  
  
  56.             if (duration < fastest) fastest = duration; 
    57. 
  
  
  
  57.         } 
    58. 
  
  
  
  58.         return fastest; 
    59. 
  
  
  
  59.     } 
    60. 
  
  
  
  60. } 
    61.

共享变量会造成数据出现问题

 
 
 
    
  
  
  
  1. public static long sideEffectSum(long n) { 
    2. 
  
  
  
  2.     Accumulator accumulator = new Accumulator(); 
    3. 
  
  
  
  3.     LongStream.rangeClosed(1, n).forEach(accumulator::add); 
    4. 
  
  
  
  4.     return accumulator.total; 
    5. 
  
  
  
  5. } 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. public static long sideEffectParallelSum(long n) { 
    8. 
  
  
  
  8.     Accumulator accumulator = new Accumulator(); 
    9. 
  
  
  
  9.     LongStream.rangeClosed(1, n).parallel().forEach(accumulator::add); 
    10. 
  
  
  
  10.     return accumulator.total; 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. public static class Accumulator { 
    14. 
  
  
  
  14.     private long total = 0; 
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16.     public void add(long value) { 
    17. 
  
  
  
  17.         total += value; 
    18. 
  
  
  
  18.     } 
    19. 
  
  
  
  19. } 
    20.

并行流的注意

  1. 尽量使用 LongStream / IntStream / DoubleStream 等原始数据流代替 Stream 来处理数字，以避免频繁拆装箱带来的额外开销
  2. 要考虑流的操作流水线的总计算成本，假设 N 是要操作的任务总数，Q 是每次操作的时间。N * Q 就是操作的总时间，Q 值越大就意味着使用并行流带来收益的可能性越大
  3. 对于较少的数据量，不建议使用并行流
  4. 容易拆分成块的流数据，建议使用并行流

网站栏目：你破坏Java代码的样子，真美！
转载来于：http://www.mswzjz.cn/qtweb/news4/99204.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

小程序开发知识

分类信息网站

网站空间　　 　香港服务器空间　　 　乐山服务器托管　　 　广东网站设计　　 　VI设计　　 　成都茶叶销售　　 　成都电商解决方案　　 　德阳服务器托管　　 　成都网络公司　　 　德阳电信机房　　 　重庆电信五里店机房　　 　雅安服务器托管　　 　成都网站排名　　 　成都石膏隔墙板　　 　成都免费网站建设公司　　 　成都网站制作　　 　定制网站建设多少钱　　 　网站建设公司　　 　软文发稿　　 　成都云服务器