Groovy Documentation

gpars
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}}
author:
Vaclav Pech Date: Oct 23, 2008


Constructor Summary
GParsPool()

 
Method Summary
static def ensurePool(def 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 T runForkJoin(AbstractForkJoinWorker rootWorker)

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

static T runForkJoin(Object args)

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

static def withExistingPool(def 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
 

Constructor Detail

GParsPool

GParsPool()


 
Method Detail

ensurePool

public static def ensurePool(def 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

public 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.
return:
Futures for the result values or exceptions of all closures


executeAsync

public 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.
return:
Futures for the result values or exceptions of all closures


executeAsyncAndWait

public 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.
return:
The result values of all closures
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.


executeAsyncAndWait

public 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.
return:
The result values of all closures
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.


retrieveCurrentPool

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


runForkJoin

public static T runForkJoin(AbstractForkJoinWorker rootWorker)
Starts a ForkJoin calculation with the supplied root worker and waits for the result.
param:
rootWorker The worker that calculates the root of the Fork/Join problem
return:
The result of the whole calculation


runForkJoin

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


withExistingPool

public static def withExistingPool(def 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)
}*  
param:
pool The thread pool to use, the pool will not be shutdown after this method returns


withPool

public 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)
}* 
param:
cl The block of code to invoke with the DSL enabled


withPool

public 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)
}* 
param:
numberOfThreads Number of threads in the newly created thread pool
param:
cl The block of code to invoke with the DSL enabled


withPool

public 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)
}* 
param:
numberOfThreads Number of threads in the newly created thread pool
param:
handler Handler for uncaught exceptions raised in code performed by the pooled threads
param:
cl The block of code to invoke with the DSL enabled


 

Groovy Documentation