因为会有性能损失。
测试代码：
1.Java 中直接使用 Java 8 的 Stream API：
package i;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* @author: Jack
* 2020-05-06 16:20
*/
public class StreamParallelDemo {
public static void main(String[] args) {
System.out.println(String.format("本计算机的核数：%d", Runtime.getRuntime().availableProcessors()));
Random random = new Random();
List<Integer> list = new ArrayList<>(100000000);
for (int i = 0; i < 100000000; i++) {
list.add(random.nextInt(100));
}
long s = getCurrentTime();
Integer ans = list.stream().reduce((a, b) -> a + b).get();
System.out.println(ans);
System.out.println(String.format("单线程计算耗时：%d ms", getCurrentTime() - s));
s = getCurrentTime();
ans = list.stream().parallel().reduce((a, b) -> a + b).get();
System.out.println(ans);
System.out.println(String.format("多线程计算耗时：%d ms", getCurrentTime() - s));
}
private static long getCurrentTime() {
return System.currentTimeMillis();
}
}
运行结果：
本计算机的核数：12
655269092
单线程计算耗时：3350 ms
655269092
多线程计算耗时：425 ms
2.Kotlin 使用 Java 8 的 Stream API：
package i
import java.util.*
/**
* @author: Jack
* 2020-05-06 16:03
*/
fun main() {
val n = 100000000
val random = Random()
val numbers = ArrayList<Int>(n)
for (i in 0..n - 1) {
numbers.add(random.nextInt(100))
}
run {
val s = System.currentTimeMillis()
val ans = singleSum(numbers)
val t = System.currentTimeMillis()
println(ans)
println("singleSum Time:${t - s}ms")
}
}
fun singleSum(numbers: List<Int>): Int {
return numbers.stream().reduce { t: Int, u: Int -> t + u }.get()
}
运行结果：
655113317
singleSum Time:3509ms
package i
import java.util.*
/**
* @author: Jack
* 2020-05-06 16:03
*/
fun main() {
val n = 100000000
val random = Random()
val numbers = ArrayList<Int>(n)
for (i in 0..n - 1) {
numbers.add(random.nextInt(100))
}
run {
val s = System.currentTimeMillis()
val ans = parallelSum(numbers)
val t = System.currentTimeMillis()
println(ans)
println("parallelSum Time:${t - s}ms")
}
}
fun parallelSum(numbers: List<Int>): Int {
return numbers.stream().parallel().reduce { t: Int, u: Int -> t + u }.get()
}
运行结果：
655149583
parallelSum Time:2911ms
看起来，Kotlin使用Java 8 的 parallel Stream API，似乎没有明显的性能提升（猜测：中间有Java-Kotlin互转带来的性能损耗？）。
3.直接使用Kotlin的 List的API：
package i
import java.util.*
/**
* @author: Jack
* 2020-05-06 16:03
*/
fun main() {
val n = 100000000
val random = Random()
val numbers = ArrayList<Int>(n)
for (i in 0..n - 1) {
numbers.add(random.nextInt(100))
}
run {
val s = System.currentTimeMillis()
val ans = listSum(numbers)
val t = System.currentTimeMillis()
println(ans)
println("listSum Time:${t - s}ms")
}
}
fun listSum(numbers: List<Int>): Int {
return numbers.stream().parallel().reduce { t: Int, u: Int -> t + u }.get()
}
运行结果：
655344706
listSum Time:3235ms
4.使用Kotlin的Sequence API
package i
import java.util.*
/**
* @author: Jack
* 2020-05-06 16:03
*/
fun main() {
val n = 100000000
val random = Random()
val numbers = MutableList(n) { random.nextInt(100) }
run {
val s = System.currentTimeMillis()
val ans = sequenceSum(numbers)
val t = System.currentTimeMillis()
println(ans)
println("sequenceSum Time:${t - s}ms")
}
}
fun sequenceSum(numbers: List<Int>): Int {
return numbers.asSequence().reduce { t: Int, u: Int -> t + u }
}
运行结果：
655104311
sequenceSum Time:3176ms
思考题
为什么会有性能损失呢?
Kotlin开发者社区
专注分享 Java、 Kotlin、Spring/Spring Boot、MySQL、redis、neo4j、NoSQL、Android、JavaScript、React、Node、函数式编程、编程思想、"高可用，高性能，高实时"大型分布式系统架构设计主题。
High availability, high performance, high real-time large-scale distributed system architecture design。
分布式框架：Zookeeper、分布式中间件框架等
分布式存储：GridFS、FastDFS、TFS、MemCache、redis等
分布式数据库：Cobar、tddl、Amoeba、Mycat
云计算、大数据、AI算法
虚拟化、云原生技术
分布式计算框架：MapReduce、Hadoop、Storm、Flink等
分布式通信机制：Dubbo、RPC调用、共享远程数据、消息队列等
消息队列MQ：Kafka、MetaQ，RocketMQ
怎样打造高可用系统：基于硬件、软件中间件、系统架构等一些典型方案的实现：HAProxy、基于Corosync+Pacemaker的高可用集群套件中间件系统
Mycat架构分布式演进
大数据Join背后的难题：数据、网络、内存和计算能力的矛盾和调和
Java分布式系统中的高性能难题：AIO，NIO，Netty还是自己开发框架？
高性能事件派发机制：线程池模型、Disruptor模型等等。。。
合抱之木，生于毫末；九层之台，起于垒土；千里之行，始于足下。不积跬步，无以至千里；不积小流，无以成江河。
