GParsPoolUtil (gpars 1.2.1)

java.lang.Object
- groovyx.gpars.GParsPoolUtil

```
public class GParsPoolUtil
extends java.lang.Object
```
This class forms the core of the DSL initialized by GParsPool. The static methods of GParsPoolUtil get attached to their first arguments (the Groovy Category mechanism) and can be then invoked as if they were part of the argument classes.

Author:

Vaclav Pech, Robert Fischer Date: Mar 10, 2010

See Also:
GParsPool

Field Summary

Fields
Modifier and Type Field and Description

private static GeneralTimer timer
Allows timeouts for async operations

Fields
Modifier and Type	Field and Description
`private static GeneralTimer`	`timer` Allows timeouts for async operations

Constructor Summary

Constructors
Constructor and Description

GParsPoolUtil()

Constructors
Constructor and Description
`GParsPoolUtil()`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`anyParallel(java.util.Collection collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static boolean`	`anyParallel(java.util.Map collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate.
`static boolean`	`anyParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static void`	`asConcurrent(java.lang.Object collection, groovy.lang.Closure code)` Makes the collection concurrent for the passed-in block of code.
`static groovy.lang.Closure`	`async(groovy.lang.Closure cl)` Creates an asynchronous variant of the supplied closure, which, when invoked returns a future for the potential return value
`static groovy.lang.Closure`	`asyncFun(groovy.lang.Closure original)` Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
`static groovy.lang.Closure`	`asyncFun(groovy.lang.Closure original, boolean blocking)` Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
`static groovy.lang.Closure`	`asyncFun(groovy.lang.Closure original, FJPool pool)` Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
`static groovy.lang.Closure`	`asyncFun(groovy.lang.Closure original, FJPool pool, boolean blocking)` Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
`static <T> java.util.concurrent.Future<T>`	`callAsync(groovy.lang.Closure<T> cl, java.lang.Object... args)` Calls a closure in a separate thread supplying the given arguments, returning a future for the potential return value.
`static <T> java.util.concurrent.Future<T>`	`callParallel(groovy.lang.Closure<T> task)` schedules the supplied closure for processing in the underlying thread pool.
`static <T> java.util.concurrent.Future<T>`	`callTimeoutAsync(groovy.lang.Closure<T> cl, groovy.time.Duration timeout, java.lang.Object... args)` Calls a closure in a separate thread supplying the given arguments, returning a future for the potential return value.
`static <T> java.util.concurrent.Future<T>`	`callTimeoutAsync(groovy.lang.Closure<T> cl, long timeout, java.lang.Object... args)` Calls a closure in a separate thread supplying the given arguments, returning a future for the potential return value.
`static <T> java.util.List<T>`	`collectManyParallel(java.util.Collection collection, groovy.lang.Closure<java.util.Collection<? extends T>> projection)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied `projection` closure as the transformation operation.
`static <T> java.util.List<T>`	`collectManyParallel(java.util.Map collection, groovy.lang.Closure<java.util.Collection<? extends T>> projection)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied `projection` closure as the transformation operation.
`static <T> java.util.List<T>`	`collectManyParallel(java.lang.Object collection, groovy.lang.Closure<java.util.Collection<? extends T>> projection)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied `projection` closure as the transformation operation.
`static <T> java.util.Collection<T>`	`collectParallel(java.util.Collection collection, groovy.lang.Closure<? extends T> cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation.
`static <T> java.util.Collection<T>`	`collectParallel(java.util.Map collection, groovy.lang.Closure<? extends T> cl)` Creates a Parallel Array out of the supplied map and invokes the withMapping() method using the supplied closure as the transformation operation.
`static <T> java.util.Collection<T>`	`collectParallel(java.lang.Object collection, groovy.lang.Closure<? extends T> cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation.
`static int`	`countParallel(java.util.Collection collection, groovy.lang.Closure filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`static int`	`countParallel(java.util.Collection collection, java.lang.Object filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`static int`	`countParallel(java.lang.Object collection, groovy.lang.Closure filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`static int`	`countParallel(java.lang.Object collection, java.lang.Object filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`private static <K,V> ParallelArray<java.util.Map.Entry<K,V>>`	`createPA(java.util.Map<K,V> collection, jsr166y.ForkJoinPool pool)`
`static <T> java.util.Collection<T>`	`eachParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation.
`static <K,V> java.util.Map<K,V>`	`eachParallel(java.util.Map<K,V> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied map and invokes the withMapping() method using the supplied closure as the transformation operation.
`static <T> T`	`eachParallel(T collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation.
`static <T> java.util.Collection<T>`	`eachWithIndexParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation.
`static <K,V> java.util.Map<K,V>`	`eachWithIndexParallel(java.util.Map<K,V> collection, groovy.lang.Closure cl)` Does parallel eachWithIndex on maps
`static <T> T`	`eachWithIndexParallel(T collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation.
`static boolean`	`everyParallel(java.util.Collection collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static boolean`	`everyParallel(java.util.Map collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate.
`static boolean`	`everyParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static <T> java.util.Collection<T>`	`findAllParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static <K,V> java.util.Map<K,V>`	`findAllParallel(java.util.Map<K,V> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate.
`static java.util.Collection<java.lang.Object>`	`findAllParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static <T> T`	`findAnyParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static <K,V> java.util.Map.Entry<K,V>`	`findAnyParallel(java.util.Map<K,V> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate.
`static java.lang.Object`	`findAnyParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static <T> T`	`findParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static <K,V> java.util.Map.Entry<K,V>`	`findParallel(java.util.Map<K,V> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate.
`static java.lang.Object`	`findParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate.
`static <T> T`	`foldParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Deprecated.
`static <T> T`	`foldParallel(java.util.Collection<T> collection, T seed, groovy.lang.Closure cl)` Deprecated.
`static java.lang.Object`	`foldParallel(java.lang.Object collection, groovy.lang.Closure cl)` Deprecated.
`static java.lang.Object`	`foldParallel(java.lang.Object collection, java.lang.Object seed, groovy.lang.Closure cl)` Deprecated.
`static <T> groovyx.gpars.pa.PAWrapper<T>`	`getParallel(java.util.Collection<T> collection)` Creates a PAWrapper around a ParallelArray wrapping the elements of the original collection.
`static groovyx.gpars.pa.PAWrapper`	`getParallel(java.lang.Object collection)` Creates a PAWrapper around a ParallelArray wrapping the elements of the original collection.
`static <T> ParallelArray<T>`	`getParallelArray(java.util.Collection<T> collection)` Creates a ParallelArray wrapping the elements of the original collection.
`static ParallelArray`	`getParallelArray(java.lang.Object collection)` Creates a ParallelArray wrapping the elements of the original collection.
`static <T> groovy.lang.Closure<T>`	`gmemoize(groovy.lang.Closure<T> cl)` Deprecated.
`static <T> groovy.lang.Closure<T>`	`gmemoizeAtLeast(groovy.lang.Closure<T> cl, int protectedCacheSize)` Deprecated.
`static <T> groovy.lang.Closure<T>`	`gmemoizeAtMost(groovy.lang.Closure<T> cl, int maxCacheSize)` Deprecated.
`static <T> groovy.lang.Closure<T>`	`gmemoizeBetween(groovy.lang.Closure<T> cl, int protectedCacheSize, int maxCacheSize)` Deprecated.
`static <T> java.util.Collection<T>`	`grepParallel(java.util.Collection<T> collection, java.lang.Object filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`static <K,V> java.util.Map<K,V>`	`grepParallel(java.util.Map<K,V> collection, java.lang.Object filter)` Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied rule as the filter predicate.
`static java.lang.Object`	`grepParallel(java.lang.Object collection, java.lang.Object filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`static <K,T> java.util.Map<K,java.util.List<T>>`	`groupByParallel(java.util.Collection<T> collection, groovy.lang.Closure<K> cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the mapping predicate.
`static <K> java.util.Map<K,java.util.List<java.lang.Object>>`	`groupByParallel(java.lang.Object collection, groovy.lang.Closure<K> cl)` Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the mapping predicate.
`private static <K,T> java.util.Map<K,java.util.List<T>>`	`groupByParallelPA(ParallelArray<T> pa, groovy.lang.Closure<K> cl)`
`static <T> T`	`injectParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation.
`static <T> T`	`injectParallel(java.util.Collection<T> collection, T seed, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation.
`static java.lang.Object`	`injectParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation.
`static java.lang.Object`	`injectParallel(java.lang.Object collection, java.lang.Object seed, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation.
`static boolean`	`isConcurrent(java.lang.Object collection)` Indicates whether the iterative methods like each() or collect() work have been altered to work concurrently.
`static <T> java.util.concurrent.Future<T>`	`leftShift(jsr166y.ForkJoinPool pool, groovy.lang.Closure<T> task)` Submits the task for asynchronous processing returning the Future received from the executor service.
`static java.lang.Object`	`makeConcurrent(java.lang.Object collection)` Overrides the iterative methods like each(), collect() and such, so that they call their parallel variants from the GParsPoolUtil class like eachParallel(), collectParallel() and such.
`static java.lang.Object`	`makeSequential(java.lang.Object collection)` Gives the iterative methods like each() or find() the original sequential semantics.
`static <T> T`	`maxParallel(java.util.Collection<T> collection)` Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the default comparator.
`static <T> T`	`maxParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the supplied closure as the comparator.
`static java.lang.Object`	`maxParallel(java.lang.Object collection)` Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the default comparator.
`static java.lang.Object`	`maxParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the supplied closure as the comparator.
`static <T> T`	`minParallel(java.util.Collection<T> collection)` Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the default comparator.
`static <T> T`	`minParallel(java.util.Collection<T> collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the supplied closure as the comparator.
`static java.lang.Object`	`minParallel(java.lang.Object collection)` Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the default comparator.
`static java.lang.Object`	`minParallel(java.lang.Object collection, groovy.lang.Closure cl)` Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the supplied closure as the comparator.
`private static jsr166y.ForkJoinPool`	`retrievePool()`
`static <T> java.util.Collection<T>`	`splitParallel(java.util.Collection<T> collection, java.lang.Object filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`static java.lang.Object`	`splitParallel(java.lang.Object collection, java.lang.Object filter)` Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate.
`static <T> T`	`sumParallel(java.util.Collection<T> collection)` Creates a Parallel Array out of the supplied collection/object and summarizes its elements using the foldParallel() method with the + operator and the reduction operation.
`static java.lang.Object`	`sumParallel(java.lang.Object collection)` Creates a Parallel Array out of the supplied collection/object and summarizes its elements using the foldParallel() method with the + operator and the reduction operation.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - timer
```
private static final GeneralTimer timer
```
    Allows timeouts for async operations
- Constructor Detail
  - GParsPoolUtil
```
public GParsPoolUtil()
```
- Method Detail
  - retrievePool
```
private static jsr166y.ForkJoinPool retrievePool()
```
  - callParallel
```
public static <T> java.util.concurrent.Future<T> callParallel(groovy.lang.Closure<T> task)
```
    schedules the supplied closure for processing in the underlying thread pool.
  - callAsync
```
public static <T> java.util.concurrent.Future<T> callAsync(groovy.lang.Closure<T> cl,
                                           java.lang.Object... args)
```
    Calls a closure in a separate thread supplying the given arguments, returning a future for the potential return value.
  - callTimeoutAsync
```
public static <T> java.util.concurrent.Future<T> callTimeoutAsync(groovy.lang.Closure<T> cl,
                                                  long timeout,
                                                  java.lang.Object... args)
```
    Calls a closure in a separate thread supplying the given arguments, returning a future for the potential return value. Also allows the asynchronous calculation to be cancelled after a given timeout. In order to allow cancellation, the asynchronously running code must keep checking the _interrupted_ flag of its own thread and cease the calculation once the flag is set to true.
    
    Parameters:
    timeout - The timeout in milliseconds to wait before the calculation gets cancelled.
  - callTimeoutAsync
```
public static <T> java.util.concurrent.Future<T> callTimeoutAsync(groovy.lang.Closure<T> cl,
                                                  groovy.time.Duration timeout,
                                                  java.lang.Object... args)
```
    Calls a closure in a separate thread supplying the given arguments, returning a future for the potential return value. Also allows the asynchronous calculation to be cancelled after a given timeout. In order to allow cancellation, the asynchronously running code must keep checking the _interrupted_ flag of its own thread and cease the calculation once the flag is set to true.
    
    Parameters:
    timeout - The timeout to wait before the calculation gets cancelled.
  - leftShift
```
public static <T> java.util.concurrent.Future<T> leftShift(jsr166y.ForkJoinPool pool,
                                           groovy.lang.Closure<T> task)
```
    Submits the task for asynchronous processing returning the Future received from the executor service. Allows for the following syntax:
```
 executorService << {println 'Inside parallel task'}
 
```
  - async
```
public static groovy.lang.Closure async(groovy.lang.Closure cl)
```
    Creates an asynchronous variant of the supplied closure, which, when invoked returns a future for the potential return value
  - asyncFun
```
public static groovy.lang.Closure asyncFun(groovy.lang.Closure original)
```
    Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
  - asyncFun
```
public static groovy.lang.Closure asyncFun(groovy.lang.Closure original,
                           boolean blocking)
```
    Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
  - asyncFun
```
public static groovy.lang.Closure asyncFun(groovy.lang.Closure original,
                           FJPool pool)
```
    Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
  - asyncFun
```
public static groovy.lang.Closure asyncFun(groovy.lang.Closure original,
                           FJPool pool,
                           boolean blocking)
```
    Creates an asynchronous and composable variant of the supplied closure, which, when invoked returns a DataflowVariable for the potential return value
  - gmemoize
```
@Deprecated
public static <T> groovy.lang.Closure<T> gmemoize(groovy.lang.Closure<T> cl)
```
    Deprecated.
    
    Creates a caching variant of the supplied closure. Whenever the closure is called, the mapping between the parameters and the return value is preserved in cache making subsequent calls with the same arguments fast. This variant will keep all values forever, i.e. till the closure gets garbage-collected. The returned function can be safely used concurrently from multiple threads, however, the implementation values high average-scenario performance and so concurrent calls on the memoized function with identical argument values may not necessarily be able to benefit from each other's cached return value. With this having been mentioned, the performance trade-off still makes concurrent use of memoized functions safe and highly recommended.
    The cache gets garbage-collected together with the memoized closure.
    
    Returns:
    A new function forwarding to the original one while caching the results
  - gmemoizeAtMost
```
@Deprecated
public static <T> groovy.lang.Closure<T> gmemoizeAtMost(groovy.lang.Closure<T> cl,
                                                   int maxCacheSize)
```
    Deprecated.
    
    Creates a caching variant of the supplied closure with upper limit on the cache size. Whenever the closure is called, the mapping between the parameters and the return value is preserved in cache making subsequent calls with the same arguments fast. This variant will keep all values until the upper size limit is reached. Then the values in the cache start rotating using the LRU (Last Recently Used) strategy. The returned function can be safely used concurrently from multiple threads, however, the implementation values high average-scenario performance and so concurrent calls on the memoized function with identical argument values may not necessarily be able to benefit from each other's cached return value. With this having been mentioned, the performance trade-off still makes concurrent use of memoized functions safe and highly recommended.
    The cache gets garbage-collected together with the memoized closure.
    
    Parameters:
    maxCacheSize - The maximum size the cache can grow to
    
    Returns:
    A new function forwarding to the original one while caching the results
  - gmemoizeAtLeast
```
@Deprecated
public static <T> groovy.lang.Closure<T> gmemoizeAtLeast(groovy.lang.Closure<T> cl,
                                                    int protectedCacheSize)
```
    Deprecated.
    
    Creates a caching variant of the supplied closure with automatic cache size adjustment and lower limit on the cache size. Whenever the closure is called, the mapping between the parameters and the return value is preserved in cache making subsequent calls with the same arguments fast. This variant allows the garbage collector to release entries from the cache and at the same time allows the user to specify how many entries should be protected from the eventual gc-initiated eviction. Cached entries exceeding the specified preservation threshold are made available for eviction based on the LRU (Last Recently Used) strategy. Given the non-deterministic nature of garbage collector, the actual cache size may grow well beyond the limits set by the user if memory is plentiful. The returned function can be safely used concurrently from multiple threads, however, the implementation values high average-scenario performance and so concurrent calls on the memoized function with identical argument values may not necessarily be able to benefit from each other's cached return value. Also the protectedCacheSize parameter might not be respected accurately in such scenarios for some periods of time. With this having been mentioned, the performance trade-off still makes concurrent use of memoized functions safe and highly recommended.
    The cache gets garbage-collected together with the memoized closure.
  - gmemoizeBetween
```
@Deprecated
public static <T> groovy.lang.Closure<T> gmemoizeBetween(groovy.lang.Closure<T> cl,
                                                    int protectedCacheSize,
                                                    int maxCacheSize)
```
    Deprecated.
    
    Creates a caching variant of the supplied closure with automatic cache size adjustment and lower and upper limits on the cache size. Whenever the closure is called, the mapping between the parameters and the return value is preserved in cache making subsequent calls with the same arguments fast. This variant allows the garbage collector to release entries from the cache and at the same time allows the user to specify how many entries should be protected from the eventual gc-initiated eviction. Cached entries exceeding the specified preservation threshold are made available for eviction based on the LRU (Last Recently Used) strategy. Given the non-deterministic nature of garbage collector, the actual cache size may grow well beyond the protected size limits set by the user, if memory is plentiful. Also, this variant will never exceed in size the upper size limit. Once the upper size limit has been reached, the values in the cache start rotating using the LRU (Last Recently Used) strategy. The returned function can be safely used concurrently from multiple threads, however, the implementation values high average-scenario performance and so concurrent calls on the memoized function with identical argument values may not necessarily be able to benefit from each other's cached return value. Also the protectedCacheSize parameter might not be respected accurately in such scenarios for some periods of time. With this having been mentioned, the performance trade-off still makes concurrent use of memoized functions safe and highly recommended.
    The cache gets garbage-collected together with the memoized closure.
  - createPA
```
private static <K,V> ParallelArray<java.util.Map.Entry<K,V>> createPA(java.util.Map<K,V> collection,
                                                     jsr166y.ForkJoinPool pool)
```
  - makeConcurrent
```
public static java.lang.Object makeConcurrent(java.lang.Object collection)
```
    Overrides the iterative methods like each(), collect() and such, so that they call their parallel variants from the GParsPoolUtil class like eachParallel(), collectParallel() and such. The first time it is invoked on a collection the method creates a TransparentParallel class instance and mixes it in the object it is invoked on. After mixing-in, the isConcurrent() method will return true. Delegates to GParsPoolUtil.makeConcurrent().
    
    Parameters:
    collection - The object to make transparent
    
    Returns:
    The instance of the TransparentParallel class wrapping the original object and overriding the iterative methods with new parallel behavior
  - makeSequential
```
public static java.lang.Object makeSequential(java.lang.Object collection)
```
    Gives the iterative methods like each() or find() the original sequential semantics.
    
    Parameters:
    collection - The collection to apply the change to
    
    Returns:
    The collection itself
  - asConcurrent
```
public static void asConcurrent(java.lang.Object collection,
                groovy.lang.Closure code)
```
    Makes the collection concurrent for the passed-in block of code. The iterative methods like each or collect are given concurrent semantics inside the passed-in closure. Once the closure finishes, the original sequential semantics of the methods is restored. Must be invoked inside a withPool block.
    
    Parameters:
    collection - The collection to enhance
    code - The closure to run with the collection enhanced.
  - isConcurrent
```
public static boolean isConcurrent(java.lang.Object collection)
```
    Indicates whether the iterative methods like each() or collect() work have been altered to work concurrently.
  - eachParallel
```
public static <T> java.util.Collection<T> eachParallel(java.util.Collection<T> collection,
                                       groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new eachParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = new ConcurrentSkipListSet()
     [1, 2, 3, 4, 5].eachParallel {Number number -> result.add(number * 10)}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
    Note that the result variable is synchronized to prevent race conditions between multiple threads.
  - eachParallel
```
public static <T> T eachParallel(T collection,
                 groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new eachParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = new ConcurrentSkipListSet()
     [1, 2, 3, 4, 5].eachParallel {Number number -> result.add(number * 10)}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
    Note that the result variable is synchronized to prevent race conditions between multiple threads.
  - eachParallel
```
public static <K,V> java.util.Map<K,V> eachParallel(java.util.Map<K,V> collection,
                                    groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied map and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new eachParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = new ConcurrentSkipListSet()
     [1, 2, 3, 4, 5].eachParallel {Number number -> result.add(number * 10)}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
    Note that the result variable is synchronized to prevent race conditions between multiple threads.
  - eachWithIndexParallel
```
public static <T> java.util.Collection<T> eachWithIndexParallel(java.util.Collection<T> collection,
                                                groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new eachWithIndexParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = new ConcurrentSkipListSet()
     [1, 2, 3, 4, 5].eachWithIndexParallel {Number number, int index -> result.add(number * 10)}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
    Note that the result variable is synchronized to prevent race conditions between multiple threads.
  - eachWithIndexParallel
```
public static <T> T eachWithIndexParallel(T collection,
                          groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new eachWithIndexParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = new ConcurrentSkipListSet()
     [1, 2, 3, 4, 5].eachWithIndexParallel {Number number, int index -> result.add(number * 10)}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
    Note that the result variable is synchronized to prevent race conditions between multiple threads.
  - eachWithIndexParallel
```
public static <K,V> java.util.Map<K,V> eachWithIndexParallel(java.util.Map<K,V> collection,
                                             groovy.lang.Closure cl)
```
    Does parallel eachWithIndex on maps
  - collectParallel
```
public static <T> java.util.Collection<T> collectParallel(java.util.Collection collection,
                                          groovy.lang.Closure<? extends T> cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new collectParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].collectParallel {Number number -> number * 10}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
  - collectParallel
```
public static <T> java.util.Collection<T> collectParallel(java.lang.Object collection,
                                          groovy.lang.Closure<? extends T> cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new collectParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].collectParallel {Number number -> number * 10}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
  - collectParallel
```
public static <T> java.util.Collection<T> collectParallel(java.util.Map collection,
                                          groovy.lang.Closure<? extends T> cl)
```
    Creates a Parallel Array out of the supplied map and invokes the withMapping() method using the supplied closure as the transformation operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new collectParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].collectParallel {Number number -> number * 10}
     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
 }
 
```
  - collectManyParallel
```
public static <T> java.util.List<T> collectManyParallel(java.util.Collection collection,
                                        groovy.lang.Closure<java.util.Collection<? extends T>> projection)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied projection closure as the transformation operation. The projection closure should return a (possibly empty) collection of items which are subsequently flattened to produce a new collection. The projection closure will be effectively invoked concurrently on the elements of the original collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new collectManyParallel(Closure projection) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def squaresAndCubesOfOdds = [1, 2, 3, 4, 5].collectManyParallel { Number number ->
         number % 2 ? [number ** 2, number ** 3] : []
     }
     assert squaresAndCubesOfOdds == [1, 1, 9, 27, 25, 125]
 }
 
```
  - collectManyParallel
```
public static <T> java.util.List<T> collectManyParallel(java.lang.Object collection,
                                        groovy.lang.Closure<java.util.Collection<? extends T>> projection)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied projection closure as the transformation operation. The projection closure should return a (possibly empty) collection of items which are subsequently flattened to produce a new collection. The projection closure will be effectively invoked concurrently on the elements of the original collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new collectManyParallel(Closure projection) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def squaresAndCubesOfOdds = [1, 2, 3, 4, 5].collectManyParallel { Number number ->
         number % 2 ? [number ** 2, number ** 3] : []
     }
     assert squaresAndCubesOfOdds == [1, 1, 9, 27, 25, 125]
 }
 
```
  - collectManyParallel
```
public static <T> java.util.List<T> collectManyParallel(java.util.Map collection,
                                        groovy.lang.Closure<java.util.Collection<? extends T>> projection)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied projection closure as the transformation operation. The projection closure should return a (possibly empty) collection of items which are subsequently flattened to produce a new collection. The projection closure will be effectively invoked concurrently on the elements of the original collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new collectManyParallel(Closure projection) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def squaresAndCubesOfOdds = [1, 2, 3, 4, 5].collectManyParallel { Number number ->
         number % 2 ? [number ** 2, number ** 3] : []
     }
     assert squaresAndCubesOfOdds == [1, 1, 9, 27, 25, 125]
 }
 
```
  - findAllParallel
```
public static <T> java.util.Collection<T> findAllParallel(java.util.Collection<T> collection,
                                          groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findAllParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findAllParallel {Number number -> number > 3}
     assertEquals(new HashSet([4, 5]), result)
 }
 
```
  - findAllParallel
```
public static java.util.Collection<java.lang.Object> findAllParallel(java.lang.Object collection,
                                                     groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findAllParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findAllParallel {Number number -> number > 3}
     assertEquals(new HashSet([4, 5]), result)
 }
 
```
  - findAllParallel
```
public static <K,V> java.util.Map<K,V> findAllParallel(java.util.Map<K,V> collection,
                                       groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findAllParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example: GParsPool.withPool { def result = [1, 2, 3, 4, 5].findAllParallel {Number number -> number > 3} assertEquals(new HashSet([4, 5]), result) }
  - findParallel
```
public static <T> T findParallel(java.util.Collection<T> collection,
                 groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a value from the resulting Parallel Array with the minimum index. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findParallel {Number number -> number > 3}
     assert (result in [4, 5])
 }
 
```
  - findParallel
```
public static java.lang.Object findParallel(java.lang.Object collection,
                            groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a value from the resulting Parallel Array with the minimum index. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findParallel {Number number -> number > 3}
     assert (result in [4, 5])
 }
 
```
  - findParallel
```
public static <K,V> java.util.Map.Entry<K,V> findParallel(java.util.Map<K,V> collection,
                                          groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a value from the resulting Parallel Array with the minimum index. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findParallel {Number number -> number > 3}
     assert (result in [4, 5])
 }
 
```
  - findAnyParallel
```
public static <T> T findAnyParallel(java.util.Collection<T> collection,
                    groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. Unlike with the find method, findAnyParallel() does not guarantee that the a matching element with the lowest index is returned. The findAnyParallel() method evaluates elements lazily and stops processing further elements of the collection once a match has been found. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a random value from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findParallel {Number number -> number > 3}
     assert (result in [4, 5])
 }
 
```
  - findAnyParallel
```
public static java.lang.Object findAnyParallel(java.lang.Object collection,
                               groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. Unlike with the find method, findAnyParallel() does not guarantee that the a matching element with the lowest index is returned. The findAnyParallel() method evaluates elements lazily and stops processing further elements of the collection once a match has been found. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a random value from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findAnyParallel {Number number -> number > 3}
     assert (result in [4, 5])
 }
 
```
  - findAnyParallel
```
public static <K,V> java.util.Map.Entry<K,V> findAnyParallel(java.util.Map<K,V> collection,
                                             groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate. Unlike with the find method, findAnyParallel() does not guarantee that the matching element with the lowest index is returned. The findAnyParallel() method evaluates elements lazily and stops processing further elements of the collection once a match has been found. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a random value from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new findParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].findAnyParallel {Number number -> number > 3}
     assert (result in [4, 5])
 }
 
```
  - grepParallel
```
public static <T> java.util.Collection<T> grepParallel(java.util.Collection<T> collection,
                                       java.lang.Object filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].grepParallel(4..6)
     assertEquals(new HashSet([4, 5]), result)
 }
 
```
  - grepParallel
```
public static java.lang.Object grepParallel(java.lang.Object collection,
                            java.lang.Object filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].grepParallel(4..6)
     assertEquals(new HashSet([4, 5]), result)
 }
 
```
  - grepParallel
```
public static <K,V> java.util.Map<K,V> grepParallel(java.util.Map<K,V> collection,
                                    java.lang.Object filter)
```
    Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].grepParallel(4..6)
     assertEquals(new HashSet([4, 5]), result)
 }
 
```
  - splitParallel
```
public static <T> java.util.Collection<T> splitParallel(java.util.Collection<T> collection,
                                        java.lang.Object filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class.
  - splitParallel
```
public static java.lang.Object splitParallel(java.lang.Object collection,
                             java.lang.Object filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].splitParallel(4..6)
     assert [3, 4, 5] as Set == result[0] as Set
     assert [1, 2] as Set == result[1] as Set
 }
 
```
  - countParallel
```
public static int countParallel(java.util.Collection collection,
                java.lang.Object filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].countParallel(4)
     assertEquals(1, result)
 }
 
```
  - countParallel
```
public static int countParallel(java.lang.Object collection,
                java.lang.Object filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def result = [1, 2, 3, 4, 5].countParallel(4)
     assertEquals(1, result)
 }
 
```
  - countParallel
```
public static int countParallel(java.util.Collection collection,
                groovy.lang.Closure filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def isOdd = { it % 2 }
     def result = [1, 2, 3, 4, 5].countParallel(isOdd)
     assert result == 3
 }
 
```
  - countParallel
```
public static int countParallel(java.lang.Object collection,
                groovy.lang.Closure filter)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied rule as the filter predicate. The filter will be effectively used concurrently on the elements of the collection. After all the elements have been processed, the method returns a collection of values from the resulting Parallel Array. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new grepParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     def isEven = { it % 2 == 0 }
     def result = [1, 2, 3, 4, 5].countParallel(isEven)
     assert result == 2
 }
 
```
  - anyParallel
```
public static boolean anyParallel(java.util.Collection collection,
                  groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. The anyParallel() method is lazy and once a positive answer has been given by at least one element, it avoids running the supplied closure on subsequent elements. After all the elements have been processed, the method returns a boolean value indicating, whether at least one element of the collection meets the predicate. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new anyParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     assert [1, 2, 3, 4, 5].anyParallel {Number number -> number > 3}
     assert ![1, 2, 3].anyParallel {Number number -> number > 3}
 }
 
```
  - anyParallel
```
public static boolean anyParallel(java.lang.Object collection,
                  groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. The anyParallel() method is lazy and once a positive answer has been given by at least one element, it avoids running the supplied closure on subsequent elements. After all the elements have been processed, the method returns a boolean value indicating, whether at least one element of the collection meets the predicate. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new anyParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     assert [1, 2, 3, 4, 5].anyParallel {Number number -> number > 3}
     assert ![1, 2, 3].anyParallel {Number number -> number > 3}
 }
 
```
  - anyParallel
```
public static boolean anyParallel(java.util.Map collection,
                  groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. The anyParallel() method is lazy and once a positive answer has been given by at least one element, it avoids running the supplied closure on subsequent elements. After all the elements have been processed, the method returns a boolean value indicating, whether at least one element of the collection meets the predicate. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new anyParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     assert [1, 2, 3, 4, 5].anyParallel {Number number -> number > 3}
     assert ![1, 2, 3].anyParallel {Number number -> number > 3}
 }
 
```
  - everyParallel
```
public static boolean everyParallel(java.util.Collection collection,
                    groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a boolean value indicating, whether all the elements of the collection meet the predicate. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new everyParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool(5) {
     assert ![1, 2, 3, 4, 5].everyParallel {Number number -> number > 3}
     assert [1, 2, 3].everyParallel() {Number number -> number <= 3}
 }
 
```
  - everyParallel
```
public static boolean everyParallel(java.lang.Object collection,
                    groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a boolean value indicating, whether all the elements of the collection meet the predicate. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new everyParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool(5) {
     assert ![1, 2, 3, 4, 5].everyParallel {Number number -> number > 3}
     assert [1, 2, 3].everyParallel() {Number number -> number <= 3}
 }
 
```
  - everyParallel
```
public static boolean everyParallel(java.util.Map collection,
                    groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied map and invokes the withFilter() method using the supplied closure as the filter predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a boolean value indicating, whether all the elements of the collection meet the predicate. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new everyParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool(5) {
     assert ![1, 2, 3, 4, 5].everyParallel {Number number -> number > 3}
     assert [1, 2, 3].everyParallel() {Number number -> number <= 3}
 }
 
```
  - groupByParallel
```
public static <K,T> java.util.Map<K,java.util.List<T>> groupByParallel(java.util.Collection<T> collection,
                                                       groovy.lang.Closure<K> cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the mapping predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a map of groups of the original elements. Elements in the same group gave identical results when the supplied closure was invoked on them. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new groupByParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     assert ([1, 2, 3, 4, 5].groupByParallel {Number number -> number % 2}).size() == 2
 }
 
```
  - groupByParallel
```
public static <K> java.util.Map<K,java.util.List<java.lang.Object>> groupByParallel(java.lang.Object collection,
                                                                    groovy.lang.Closure<K> cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes the withMapping() method using the supplied closure as the mapping predicate. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns a map of groups of the original elements. Elements in the same group gave identical results when the supplied closure was invoked on them. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new groupByParallel(Closure cl) method, which delegates to the GParsPoolUtil class. Example:
```
 GParsPool.withPool {
     assert ([1, 2, 3, 4, 5].groupByParallel {Number number -> number % 2}).size() == 2
 }
 
```
  - groupByParallelPA
```
private static <K,T> java.util.Map<K,java.util.List<T>> groupByParallelPA(ParallelArray<T> pa,
                                                         groovy.lang.Closure<K> cl)
```
  - minParallel
```
public static <T> T minParallel(java.util.Collection<T> collection,
                groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the supplied closure as the comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the minimum of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new min(Closure cl) method, which delegates to the GParsPoolUtil class. If the supplied closure takes two arguments it is used directly as a comparator. If the supplied closure takes one argument, the values returned by the supplied closure for individual elements are used for comparison by the implicit comparator.
    
    Parameters:
    cl - A one or two-argument closure
  - minParallel
```
public static java.lang.Object minParallel(java.lang.Object collection,
                           groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the supplied closure as the comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the minimum of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new min(Closure cl) method, which delegates to the GParsPoolUtil class. If the supplied closure takes two arguments it is used directly as a comparator. If the supplied closure takes one argument, the values returned by the supplied closure for individual elements are used for comparison by the implicit comparator.
    
    Parameters:
    cl - A one or two-argument closure
  - minParallel
```
public static <T> T minParallel(java.util.Collection<T> collection)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the default comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the minimum of the elements in the collection. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new min(Closure cl) method, which delegates to the GParsPoolUtil class.
  - minParallel
```
public static java.lang.Object minParallel(java.lang.Object collection)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its min() method using the default comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the minimum of the elements in the collection. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new min(Closure cl) method, which delegates to the GParsPoolUtil class.
  - maxParallel
```
public static <T> T maxParallel(java.util.Collection<T> collection,
                groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the supplied closure as the comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the maximum of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new max(Closure cl) method, which delegates to the GParsPoolUtil class. If the supplied closure takes two arguments it is used directly as a comparator. If the supplied closure takes one argument, the values returned by the supplied closure for individual elements are used for comparison by the implicit comparator.
    
    Parameters:
    cl - A one or two-argument closure
  - maxParallel
```
public static java.lang.Object maxParallel(java.lang.Object collection,
                           groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the supplied closure as the comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the maximum of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new max(Closure cl) method, which delegates to the GParsPoolUtil class. If the supplied closure takes two arguments it is used directly as a comparator. If the supplied closure takes one argument, the values returned by the supplied closure for individual elements are used for comparison by the implicit comparator.
    
    Parameters:
    cl - A one or two-argument closure
  - maxParallel
```
public static <T> T maxParallel(java.util.Collection<T> collection)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the default comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the maximum of the elements in the collection. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new max(Closure cl) method, which delegates to the GParsPoolUtil class.
  - maxParallel
```
public static java.lang.Object maxParallel(java.lang.Object collection)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its max() method using the default comparator. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the maximum of the elements in the collection. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new max(Closure cl) method, which delegates to the GParsPoolUtil class.
  - sumParallel
```
public static <T> T sumParallel(java.util.Collection<T> collection)
```
    Creates a Parallel Array out of the supplied collection/object and summarizes its elements using the foldParallel() method with the + operator and the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the sum of the elements in the collection. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new sun(Closure cl) method, which delegates to the GParsPoolUtil class.
  - sumParallel
```
public static java.lang.Object sumParallel(java.lang.Object collection)
```
    Creates a Parallel Array out of the supplied collection/object and summarizes its elements using the foldParallel() method with the + operator and the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the sum of the elements in the collection. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new sum(Closure cl) method, which delegates to the GParsPoolUtil class.
  - foldParallel
```
@Deprecated
public static <T> T foldParallel(java.util.Collection<T> collection,
                            groovy.lang.Closure cl)
```
    Deprecated.
    
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
  - foldParallel
```
@Deprecated
public static java.lang.Object foldParallel(java.lang.Object collection,
                                       groovy.lang.Closure cl)
```
    Deprecated.
    
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
  - foldParallel
```
@Deprecated
public static <T> T foldParallel(java.util.Collection<T> collection,
                            T seed,
                            groovy.lang.Closure cl)
```
    Deprecated.
    
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
    
    Parameters:
    seed - A seed value to initialize the operation
  - foldParallel
```
@Deprecated
public static java.lang.Object foldParallel(java.lang.Object collection,
                                       java.lang.Object seed,
                                       groovy.lang.Closure cl)
```
    Deprecated.
    
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
    
    Parameters:
    seed - A seed value to initialize the operation
  - injectParallel
```
public static <T> T injectParallel(java.util.Collection<T> collection,
                   groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
  - injectParallel
```
public static java.lang.Object injectParallel(java.lang.Object collection,
                              groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
  - injectParallel
```
public static <T> T injectParallel(java.util.Collection<T> collection,
                   T seed,
                   groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
    
    Parameters:
    seed - A seed value to initialize the operation
  - injectParallel
```
public static java.lang.Object injectParallel(java.lang.Object collection,
                              java.lang.Object seed,
                              groovy.lang.Closure cl)
```
    Creates a Parallel Array out of the supplied collection/object and invokes its reduce() method using the supplied closure as the reduction operation. The closure will be effectively invoked concurrently on the elements of the collection. After all the elements have been processed, the method returns the reduction result of the elements in the collection. It's important to protect any shared resources used by the supplied closure from race conditions caused by multi-threaded access. Alternatively a DSL can be used to simplify the code. All collections/objects within the withPool block have a new reduce(Closure cl) method, which delegates to the GParsPoolUtil class.
    
    Parameters:
    seed - A seed value to initialize the operation
  - getParallel
```
public static <T> groovyx.gpars.pa.PAWrapper<T> getParallel(java.util.Collection<T> collection)
```
    Creates a PAWrapper around a ParallelArray wrapping the elements of the original collection. This allows further parallel processing operations on the collection to chain and so effectively leverage the underlying ParallelArray implementation.
  - getParallel
```
public static groovyx.gpars.pa.PAWrapper getParallel(java.lang.Object collection)
```
    Creates a PAWrapper around a ParallelArray wrapping the elements of the original collection. This allows further parallel processing operations on the collection to chain and so effectively leverage the underlying ParallelArray implementation.
  - getParallelArray
```
public static <T> ParallelArray<T> getParallelArray(java.util.Collection<T> collection)
```
    Creates a ParallelArray wrapping the elements of the original collection.
  - getParallelArray
```
public static ParallelArray getParallelArray(java.lang.Object collection)
```
    Creates a ParallelArray wrapping the elements of the original collection.

Class GParsPoolUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

timer

Constructor Detail

GParsPoolUtil

Method Detail

retrievePool

callParallel

callAsync

callTimeoutAsync

callTimeoutAsync

leftShift

async

asyncFun

asyncFun

asyncFun

asyncFun

gmemoize

gmemoizeAtMost

gmemoizeAtLeast

gmemoizeBetween

createPA

makeConcurrent

makeSequential

asConcurrent

isConcurrent

eachParallel

eachParallel

eachParallel

eachWithIndexParallel

eachWithIndexParallel

eachWithIndexParallel

collectParallel

collectParallel

collectParallel

collectManyParallel

collectManyParallel

collectManyParallel

findAllParallel

findAllParallel

findAllParallel

findParallel

findParallel

findParallel

findAnyParallel

findAnyParallel

findAnyParallel

grepParallel

grepParallel

grepParallel

splitParallel

splitParallel

countParallel

countParallel

countParallel

countParallel

anyParallel

anyParallel

anyParallel

everyParallel

everyParallel

everyParallel

groupByParallel

groupByParallel

groupByParallelPA

minParallel

minParallel

minParallel

minParallel

maxParallel

maxParallel

maxParallel

maxParallel

sumParallel

sumParallel

foldParallel