for 循环中的并行流parallelStream

因为公司接口性能要求，检查发现性能瓶颈在于 for 循环的数量太大，循环体执行时间过长，导致性能变差。

如何优化这块性能，想到了最近看到的jdk8 的parallelStream ，考虑试下是否讲原来的串行换成并行，是否可以达到性能提升的目的。

考虑到也是刚刚接触parallelStream 相关的代码，先实现了简单的例子，确认for 循环的parallelStream 实现方法。

//原来strList [Test0, Test1, Test2, Test3, Test4]

//实现对象中的函数方法，map 有返回值，返回对应函数中的方法

List list0 = strList.parallelStream() .map(String::toUpperCase) .collect( Collectors.toList());

//List 中String 都实现toUpperCase，原来的List 不变，生成新的List

System.out.println("map 实现返回对象自带方法list0 "+list0.toString());// 输出值[TEST0, TEST1, TEST2, TEST3, TEST4]

System.out.println("map 实现返回对象自带方法strList "+strList.toString());// 输出值 [Test0, Test1, Test2, Test3, Test4]

//实现自定义的函数方法，List 中的对象作为入参，实现函数方法，map 有返回值，生成新的List,原来list不变

List list1 = strList.parallelStream().map(s->dealStr(s)).collect( Collectors.toList());

System.out.println("map 实现返回自定义的函数方法list1 "+list1.toString());// 输出值[Demo0, Demo1, Demo2, Demo3, Demo4]

System.out.println("map 实现返回自定义的函数方法原strList"+strList.toString());// 输出值 [Test0, Test1, Test2, Test3, Test4

//实现自定义的函数方法，List 中的对象和外部值作为入参，实现函数方法，map 有返回值，生成新的List,原来list不变

int index = 1;

List list2 = strList.parallelStream() .map(s->dealStr(s,index)).collect( Collectors.toList());

System.out.println("map 实现返回自定义的函数方法list2 "+list2.toString());// 输出值 [Demo01, Demo11, Demo21, Demo31, Demo41]

System.out.println("map 实现返回自定义的函数方法原strList"+strList.toString());// 输出值 [Test0, Test1, Test2, Test3, Test4]

//实现对象中的函数方法，peek 没有返回值，实现对应函数中的方法，原来List值不变

strList.parallelStream().peek(String::toUpperCase);

System.out.println("peek 实现返回对象自带方法strList "+strList.toString()); // 输出值[Test0, Test1, Test2, Test3, Test4]

//实现自定义的函数方法，peek 没有返回值，List 中的对象作为入参，改变了List 对象

strList.parallelStream().peek(s->dealStr(s));

System.out.println("peek 实现返回对象自带方法strList "+strList.toString()); // 输出值[Test0, Test1, Test2, Test3, Test4]

//不考虑硬件等条件，简单比较当前效率，

long time0 = System.currentTimeMillis();

List list3 =new ArrayList();

for(String str:strList){

list3.add(getHashCode(str));

}

long time1 = System.currentTimeMillis();

System.out.println("长度"+strList.size()+" for循环串行耗时: "+ (time1-time0));

List list4 = strList.parallelStream().map(s->getHashCode(s)).collect( Collectors.toList());

long time2 = System.currentTimeMillis();

System.out.println("长度"+strList.size()+" for循环并行耗时: "+ (time2-time1));

//输出值:

// 长度1000 for循环串行耗时: 1

// 长度1000 for循环并行耗时: 44

// 长度10000 for循环串行耗时: 2

// 长度10000 for循环并行耗时: 45

// 长度100000 for循环串行耗时: 13

// 长度100000 for循环并行耗时: 67

// 长度1000000 for循环串行耗时: 591

// 长度1000000 for循环并行耗时: 108

// 长度2000000 for循环串行耗时: 635

// 长度2000000 for循环并行耗时: 143

// 长度3000000 for循环串行耗时: 236

// 长度3000000 for循环并行耗时: 295

// 长度5000000 for循环串行耗时: 574

// 长度5000000 for循环并行耗时: 2371

// 长度10000000 for循环串行耗时: 4785

// 长度10000000 for循环并行耗时: 5574

//经过本地简单测试验证，发现并行性能不是一定优于串行，只是在一定数量的时候，并行性能会优于串行，少量数据时，串行性能还是高于并行

/**

下面是上文实现中简单额函数方法

public static String dealStr (String s){

return s.replace( "Test","Demo" );

}

public static String dealStr (String s,int i){

return s.replace( "Test","Demo" )+i;

}

public static List map1212(String s,int d){

System.

out.println("ss "+ s+d);

List students =

new ArrayList();

students.add(

"ss "+ s +" "+d);

return students;

}

public static int getHashCode (String s){

int hash = 0;

int h = hash;

char value[] = s.toCharArray();

if (h == 0 && value.length > 0) {

char val[] = value;

for (int i = 0; i < value.length; i++) {

h =

31 * h + val[i];

}

hash = h;

}

return hash;

}