Java是否具有类似于c ++的可组合内容？

Question

I am using .parallelStream().forEach() to do a bunch of writes to a DB, but would also like to keep a count of the rows I've written.

Right now, I have an java.util.concurrent.atomic.AtomicInteger to keep track of the count, but I would like to use something similar to c++'s combinable<> .

In this article , there is an example of the use of combinable<> :

#include <iostream>
#include <cstdint>
#include <ppl.h>

using namespace Concurrency;

const int max_sum_item = 1000000000;

int main()
{
    combinable<uint64_t> part_sums([] { return 0; });

    parallel_for(0, max_sum_item,
        [&part_sums] (int i)
        {
            part_sums.local() += i;
        }
    );

    uint64_t result = part_sums.combine(std::plus<uint64_t>());

    if (result != uint64_t(499999999500000000))
        throw;
}

Is there an equivalent combinable<> class in Java?

Java code snippet:

AtomicInteger totalRows = new AtomicInteger(0);
...
myList.parallelStream().forEach(
    ... // write to db
    totalRows.addAndGet(rowsWritten);
    ...
);

print(totalRows.get());

Looking for something like:

Combinable<int> totalRows = new Combinable<>(0);
...
myList.parallelStream().forEach(
    ... // write to db
    totalRows = rowsWritten;
    ...
);

print(totalRows.combine());

EDIT: as per @zero323, the right tool in Spark would be an Accumulator . I'm more interested in a multi-threaded case, but don't have a non-Spark example on hand atm.

EDIT2: Updated example (and removing Spark references)

Answer 1

A right tool in Spark would be an Accumulator :

Accumulator<Integer> accum = sc.accumulator(0);

myRDD.parallelStream().forEach(
    accum.add(1);
);

accum.value();

Accumulators are write-only from a worker perspective and only can be read only by a driver. By default it supports only Long , Double and Float but you can implement a custom AccumulatorParam to support other types.