com.pivovarit.collectors

Class ParallelCollectors.Batching

java.lang.Object

com.pivovarit.collectors.ParallelCollectors.Batching

Enclosing class:

ParallelCollectors

public static final class ParallelCollectors.Batching
extends java.lang.Object

A subset of collectors which perform operations in batches and not separately (one object in a thread pool's worker queue represents a batch of operations to be performed by a single thread)

Method Summary

Modifier and Type	Method and Description
static <T,R,RR> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<RR>>	parallel(java.util.function.Function<T,R> mapper, java.util.stream.Collector<R,?,RR> collector, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning them as a CompletableFuture containing a result of the application of the user-provided Collector.
static <T,R> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>>	parallel(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning them as CompletableFuture containing a Stream of these elements.
static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>>	parallelToOrderedStream(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive while maintaining the initial order.
static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>>	parallelToStream(java.util.function.Function<T,R> mapper, java.util.concurrent.Executor executor, int parallelism) A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

parallel

public static <T,R,RR> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<RR>> parallel(java.util.function.Function<T,R> mapper,
                                                                                                           java.util.stream.Collector<R,?,RR> collector,
                                                                                                           java.util.concurrent.Executor executor,
                                                                                                           int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning them as a CompletableFuture containing a result of the application of the user-provided Collector.
Example:

 CompletableFuture<List<String>> result = Stream.of(1, 2, 3)
   .collect(parallel(i -> foo(i), toList(), executor, 2));
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

RR - the reduction result collector

Parameters:

mapper - a transformation to be performed in parallel

collector - the Collector describing the reduction

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a user-provided mutable Collection in parallel

Since:

2.1.0

parallel

public static <T,R> java.util.stream.Collector<T,?,java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>> parallel(java.util.function.Function<T,R> mapper,
                                                                                                                                java.util.concurrent.Executor executor,
                                                                                                                                int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning them as CompletableFuture containing a Stream of these elements.

The max parallelism level defaults to Runtime.availableProcessors() - 1

The collector maintains the order of processed Stream. Instances should not be reused.
Example:

 CompletableFuture<Stream<String>> result = Stream.of(1, 2, 3)
   .collect(parallel(i -> foo(), executor, 2));
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.1.0

parallelToStream

public static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>> parallelToStream(java.util.function.Function<T,R> mapper,
                                                                                                java.util.concurrent.Executor executor,
                                                                                                int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive.

For the parallelism of 1, the stream is executed by the calling thread.
Example:

 Stream.of(1, 2, 3)
   .collect(parallelToStream(i -> foo(), executor, 2))
   .forEach(System.out::println);
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.1.0

parallelToOrderedStream

public static <T,R> java.util.stream.Collector<T,?,java.util.stream.Stream<R>> parallelToOrderedStream(java.util.function.Function<T,R> mapper,
                                                                                                       java.util.concurrent.Executor executor,
                                                                                                       int parallelism)

A convenience Collector used for executing parallel computations on a custom Executor and returning a Stream instance returning results as they arrive while maintaining the initial order.

For the parallelism of 1, the stream is executed by the calling thread.
Example:

 Stream.of(1, 2, 3)
   .collect(parallelToOrderedStream(i -> foo(), executor, 2))
   .forEach(System.out::println);
 

Type Parameters:

T - the type of the collected elements

R - the result returned by mapper

Parameters:

mapper - a transformation to be performed in parallel

executor - the Executor to use for asynchronous execution

parallelism - the max parallelism level

Returns:

a Collector which collects all processed elements into a Stream in parallel

Since:

2.1.0