Java8并行流问题

代码的问题是，当我从DB获得响应时，当使用并行流进行迭代时，每次的数据大小都不同，而使用顺序流时，它工作正常

我不能使用连续的

流

，因为数据量很大而且需要时间

---

任何潜在客户都会有帮助。

您正在添加与

salesAggrData

并行的元素，我假设它是一些

集合。如果它不是线程安全的
集合
，难怪会得到不一致的结果

为什么不使用
forEach
，而使用
map（）
，然后将结果收集到一些
集合中呢

    _logger.info("data size : "+saleData.size);

    saleData.parallelStream().forEach(data -> {
                SaleAggrData saleAggrData = new SaleAggrData() {
                    {
                        setCatId(data.getCatId());
                        setRevenue(RoundUpUtil.roundUpDouble(data.getRevenue()));
                        setMargin(RoundUpUtil.roundUpDouble(data.getMargin()));
                        setUnits(data.getUnits());
                        setMarginRate(ComputeUtil.marginRate(data.getRevenue(), data.getMargin()));
                        setOtd(ComputeUtil.OTD(data.getRevenue(), data.getUnits()));
                        setSaleDate(data.getSaleDate());
                        setDiscountDepth(ComputeUtil.discountDepth(data.getRegularPrice(), data.getRevenue()));
                        setTransactions(data.getTransactions());
                        setUpt(ComputeUtil.UPT(data.getUnits(), data.getTransactions()));
                    }
                };
                salesAggrData.addSaleAggrData(saleAggrData);
            });

列出salesAggrData=
saleData.parallelStream（）
.map（数据->{
SaleAggrData SaleAggrData=新SaleAggrData（）{
{
setCatId（data.getCatId（））；
setRevenue（RoundUpUtil.roundUpDouble（data.getRevenue（））；
setMargin（RoundUpUtil.roundUpDouble（data.getMargin（））；
setUnits（data.getUnits（））；
setMarginRate（ComputeUtil.marginRate（data.getRevenue（），data.getMargin（））；
setOtd（ComputeUtil.OTD（data.getRevenue（），data.getUnits（））；
setSaleDate（data.getSaleDate（））；
setDiscountDepth（ComputeUtil.discountDepth（data.getRegularPrice（），data.getRevenue（））；
setTransactions（data.getTransactions（））；
setUpt（ComputeUtil.UPT（data.getUnits（），data.getTransactions（））；
}
};
返回saleAggrData；
})
.collect（Collectors.toList（））；

顺便说一句，我可能会更改匿名类实例的创建，并使用命名类的构造函数来创建
SaleAggrData
实例。
而且我可能会使用顺序流，因为并行流可能会使速度变慢，而且大部分时间可能都花在执行查询和加载结果上，而不是转换结果。@JBNizet也许您是正确的，但与顺序流相比，这不会影响测试并行流的性能。请注意-您使用的是
SaleAggrData
类的匿名子类，这是不必要的。这将对性能产生影响，因为必须在运行时加载额外的类。您最好使用
SaleAggrData sad=new SaleAggrData（）；悲伤的，悲伤的；可悲的是，设置收入（…）。但数据大小在流执行之前记录。。。你在说什么？salesAggrData是线程安全的集合吗？
List<SaleAggrData> salesAggrData =
    saleData.parallelStream()
            .map(data -> {
                    SaleAggrData saleAggrData = new SaleAggrData() {
                        {
                            setCatId(data.getCatId());
                            setRevenue(RoundUpUtil.roundUpDouble(data.getRevenue()));
                            setMargin(RoundUpUtil.roundUpDouble(data.getMargin()));
                            setUnits(data.getUnits());
                            setMarginRate(ComputeUtil.marginRate(data.getRevenue(), data.getMargin()));
                            setOtd(ComputeUtil.OTD(data.getRevenue(), data.getUnits()));
                            setSaleDate(data.getSaleDate());
                            setDiscountDepth(ComputeUtil.discountDepth(data.getRegularPrice(), data.getRevenue()));
                            setTransactions(data.getTransactions());
                            setUpt(ComputeUtil.UPT(data.getUnits(), data.getTransactions()));
                        }
                    };
                    return saleAggrData;
            })
            .collect(Collectors.toList());