Groovy Documentation

gpars
[Groovy] Class GParsPool

java.lang.Object
  gpars.GParsPool

class GParsPool

Enables a ParallelArray-based (from JSR-166y) DSL on collections. In general cases the Parallel Array implementation shows to be much faster (10 - 20 times) compared to the executor service implementation in GParsExecutorsPool. E.g.

 GParsPool.withPool(5) {final AtomicInteger result = new AtomicInteger(0)
 [1, 2, 3, 4, 5].eachParallel {result.addAndGet(it)}assertEquals 15, result}GParsPool.withPool(5) {final List result = [1, 2, 3, 4, 5].collectParallel {it * 2}assert ([2, 4, 6, 8, 10].equals(result))}GParsPool.withPool(5) {assert [1, 2, 3, 4, 5].everyParallel {it > 0}assert ![1, 2, 3, 4, 5].everyParallel {it > 1}}
Authors:
Vaclav Pech Date: Oct 23, 2008


Method Summary
static def ensurePool(jsr166y.forkjoin.ForkJoinPool pool, groovy.lang.Closure cl)

Just like withExistingPool() registers a thread pool, but doesn't install the GParsPoolUtil category.

static List executeAsync(groovy.lang.Closure... closures)

Starts multiple closures in separate threads, collecting Futures for their return values Reuses the pool defined by the surrounding withPool() call.

static List executeAsync(List closures)

Starts multiple closures in separate threads, collecting Futures for their return values Reuses the pool defined by the surrounding withPool() call.

static List executeAsyncAndWait(groovy.lang.Closure... closures)

Starts multiple closures in separate threads, collecting their return values Reuses the pool defined by the surrounding withPool() call.

static List executeAsyncAndWait(List closures)

Starts multiple closures in separate threads, collecting their return values Reuses the pool defined by the surrounding withPool() call.

protected static def retrieveCurrentPool()

Retrieves the pool assigned to the current thread.

static Object runForkJoin(AbstractForkJoinWorker rootWorker)

Starts a ForkJoin calculation with the supplied root worker and waits for the result.

static Object runForkJoin(Object... args)

Starts a ForkJoin calculation with the supplied root worker and waits for the result.

static def withExistingPool(jsr166y.forkjoin.ForkJoinPool pool, groovy.lang.Closure cl)

Reuses an instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure.

static def withPool(groovy.lang.Closure cl)

Creates a new instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure.

static def withPool(int numberOfThreads, groovy.lang.Closure cl)

Creates a new instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure.

static def withPool(int numberOfThreads, UncaughtExceptionHandler handler, groovy.lang.Closure cl)

Creates a new instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure.

 
Methods inherited from class Object
wait, wait, wait, equals, toString, hashCode, getClass, notify, notifyAll
 

Method Detail

ensurePool

static def ensurePool(jsr166y.forkjoin.ForkJoinPool pool, groovy.lang.Closure cl)
Just like withExistingPool() registers a thread pool, but doesn't install the GParsPoolUtil category. Used by ParallelEnhancer's Parallel mixins.


executeAsync

static List executeAsync(groovy.lang.Closure... closures)
Starts multiple closures in separate threads, collecting Futures for their return values Reuses the pool defined by the surrounding withPool() call. If an exception is thrown from the closure when called on any of the collection's elements, it will be re-thrown in the calling thread when it calls the Future.get() method.
Returns:
Futures for the result values or exceptions of all closures


executeAsync

static List executeAsync(List closures)
Starts multiple closures in separate threads, collecting Futures for their return values Reuses the pool defined by the surrounding withPool() call. If an exception is thrown from the closure when called on any of the collection's elements, it will be re-thrown in the calling thread when it calls the Future.get() method.
Returns:
Futures for the result values or exceptions of all closures


executeAsyncAndWait

static List executeAsyncAndWait(groovy.lang.Closure... closures)
Starts multiple closures in separate threads, collecting their return values Reuses the pool defined by the surrounding withPool() call. If an exception is thrown from the closure when called on any of the collection's elements, it will be re-thrown in the calling thread when it calls the Future.get() method.
throws:
AsyncException If any of the collection's elements causes the closure to throw an exception. The original exceptions will be stored in the AsyncException's concurrentExceptions field.
Returns:
The result values of all closures


executeAsyncAndWait

static List executeAsyncAndWait(List closures)
Starts multiple closures in separate threads, collecting their return values Reuses the pool defined by the surrounding withPool() call. If an exception is thrown from the closure when called on any of the collection's elements, it will be re-thrown in the calling thread when it calls the Future.get() method.
throws:
AsyncException If any of the collection's elements causes the closure to throw an exception. The original exceptions will be stored in the AsyncException's concurrentExceptions field.
Returns:
The result values of all closures


retrieveCurrentPool

protected static def retrieveCurrentPool()
Retrieves the pool assigned to the current thread.


runForkJoin

static Object runForkJoin(AbstractForkJoinWorker rootWorker)
Starts a ForkJoin calculation with the supplied root worker and waits for the result.
Parameters:
rootWorker - The worker that calculates the root of the Fork/Join problem
Returns:
The result of the whole calculation


runForkJoin

static Object runForkJoin(Object... args)
Starts a ForkJoin calculation with the supplied root worker and waits for the result.
Parameters:
rootWorker - The worker that calculates the root of the Fork/Join problem
Returns:
The result of the whole calculation


withExistingPool

static def withExistingPool(jsr166y.forkjoin.ForkJoinPool pool, groovy.lang.Closure cl)
Reuses an instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure. Within the supplied code block the ForkJoinPool is available as the only parameter, collections have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsPoolUtil category class. E.g. calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel. Be sure to synchronize all modifiable state shared by the asynchronously running closures.
 GParsPool.withExistingPool(anotherPool) {GParsPool pool ->
     def result = Collections.synchronizedSet(new HashSet())
     [1, 2, 3, 4, 5].eachParallel {Number number -> result.add(number * 10)}*     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
}*  
Parameters:
pool - The thread pool to use, the pool will not be shutdown after this method returns


withPool

static def withPool(groovy.lang.Closure cl)
Creates a new instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure. Within the supplied code block the ForkJoinPool is available as the only parameter, collections have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsPoolUtil category class. E.g. calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel. Be sure to synchronize all modifiable state shared by the asynchronously running closures.
 GParsPool.withPool {GParsPool pool ->
     def result = Collections.synchronizedSet(new HashSet())
     [1, 2, 3, 4, 5].eachParallel {Number number -> result.add(number * 10)}*     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
}* 
Parameters:
cl - The block of code to invoke with the DSL enabled


withPool

static def withPool(int numberOfThreads, groovy.lang.Closure cl)
Creates a new instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure. Within the supplied code block the ForkJoinPool is available as the only parameter, collections have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsPoolUtil category class. E.g. calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel. Be sure to synchronize all modifiable state shared by the asynchronously running closures.
 GParsPool.withPool(5) {GParsPool pool ->
     def result = Collections.synchronizedSet(new HashSet())
     [1, 2, 3, 4, 5].eachParallel {Number number -> result.add(number * 10)}*     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
}* 
Parameters:
numberOfThreads - Number of threads in the newly created thread pool
cl - The block of code to invoke with the DSL enabled


withPool

static def withPool(int numberOfThreads, UncaughtExceptionHandler handler, groovy.lang.Closure cl)
Creates a new instance of ForkJoinPool, binds it to the current thread, enables the ParallelArray DSL and runs the supplied closure. Within the supplied code block the ForkJoinPool is available as the only parameter, collections have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsPoolUtil category class. E.g. calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel. Be sure to synchronize all modifiable state shared by the asynchronously running closures.
 GParsPool.withPool(5, handler) {GParsPool pool ->
     def result = Collections.synchronizedSet(new HashSet())
     [1, 2, 3, 4, 5].eachParallel {Number number -> result.add(number * 10)}*     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
}* 
Parameters:
numberOfThreads - Number of threads in the newly created thread pool
handler - Handler for uncaught exceptions raised in code performed by the pooled threads
cl - The block of code to invoke with the DSL enabled


 

Groovy Documentation