org.codehaus.gpars

groovyx.gpars
[Groovy] Class GParsExecutorsPool

java.lang.Object
  groovyx.gpars.GParsExecutorsPool

class GParsExecutorsPool
extends java.lang.Object

Enables a ExecutorService-based DSL on closures, objects and collections. E.g. GParsExecutorsPool.withPool(5) {ExecutorService service -> Collection result = [1, 2, 3, 4, 5].collectParallel({it * 10}.async()) assertEquals(new HashSet([10, 20, 30, 40, 50]), new HashSet((Collection)result*.get())) }* GParsExecutorsPool.withPool(5) {ExecutorService service -> def result = [1, 2, 3, 4, 5].findParallel{Number number -> number > 2}* assert result in [3, 4, 5] }*

Authors:
Vaclav Pech Date: Oct 23, 2008


Field Summary
private static ThreadLocalPools currentPoolStack

Maps threads to their appropriate thread pools

private static int defaultPoolSize

Caches the default pool size.

 
Constructor Summary
GParsExecutorsPool()

 
Method Summary
private static java.util.concurrent.ThreadFactory createDefaultThreadFactory()

private static java.lang.Object createPool()

Creates a new pool with the default size()

private static java.lang.Object createPool(int poolSize)

Creates a new pool with the given size()

private static java.lang.Object createPool(int poolSize, java.util.concurrent.ThreadFactory threadFactory)

static java.util.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 java.util.List executeAsync(java.util.List closures)

Starts multiple closures in separate threads, collecting Futures for their return values 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.

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

Starts multiple closures in separate threads, collecting their return values 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.

static java.util.List executeAsyncAndWait(java.util.List closures)

Starts multiple closures in separate threads, collecting their return values 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.

protected static java.util.concurrent.ExecutorService retrieveCurrentPool()

Retrieves the pool assigned to the current thread.

static java.lang.Object speculate(java.util.List alternatives)

Runs the supplied closures asynchronously and in parallel, returning the first result obtained and cancelling the other (slower) calculations.

static java.lang.Object speculate(groovy.lang.Closure alternatives)

Runs the supplied closures asynchronously and in parallel, returning the first result obtained and cancelling the other (slower) calculations.

static java.lang.Object withExistingPool(java.util.concurrent.ExecutorService pool, groovy.lang.Closure cl)

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

static java.lang.Object withPool(groovy.lang.Closure cl)

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

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

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

static java.lang.Object withPool(int numberOfThreads, java.util.concurrent.ThreadFactory threadFactory, groovy.lang.Closure cl)

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

 
Methods inherited from class java.lang.Object
java.lang.Object#wait(long), java.lang.Object#wait(), java.lang.Object#wait(long, int), java.lang.Object#equals(java.lang.Object), java.lang.Object#toString(), java.lang.Object#hashCode(), java.lang.Object#getClass(), java.lang.Object#notify(), java.lang.Object#notifyAll()
 

Field Detail

currentPoolStack

private static final ThreadLocalPools currentPoolStack
Maps threads to their appropriate thread pools


defaultPoolSize

private static final int defaultPoolSize
Caches the default pool size.


 
Constructor Detail

GParsExecutorsPool

GParsExecutorsPool()


 
Method Detail

createDefaultThreadFactory

private static java.util.concurrent.ThreadFactory createDefaultThreadFactory()


createPool

private static java.lang.Object createPool()
Creates a new pool with the default size()


createPool

private static java.lang.Object createPool(int poolSize)
Creates a new pool with the given size()


createPool

private static java.lang.Object createPool(int poolSize, java.util.concurrent.ThreadFactory threadFactory)


executeAsync

static java.util.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 java.util.List executeAsync(java.util.List closures)
Starts multiple closures in separate threads, collecting Futures for their return values 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 java.util.List executeAsyncAndWait(groovy.lang.Closure closures)
Starts multiple closures in separate threads, collecting their return values 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 java.util.List executeAsyncAndWait(java.util.List closures)
Starts multiple closures in separate threads, collecting their return values 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 java.util.concurrent.ExecutorService retrieveCurrentPool()
Retrieves the pool assigned to the current thread.


speculate

static java.lang.Object speculate(java.util.List alternatives)
Runs the supplied closures asynchronously and in parallel, returning the first result obtained and cancelling the other (slower) calculations. Typically used to run several different calculations in parallel, all of which are supposed to give the same result, but may last different amount of time each. If the system has enough threads available, the calculations can be test-run in parallel and the fastest result is then used, while the other results are cancelled or discarded.
Parameters:
alternatives - All the functions to invoke in parallel
Returns:
The fastest result obtained


speculate

static java.lang.Object speculate(groovy.lang.Closure alternatives)
Runs the supplied closures asynchronously and in parallel, returning the first result obtained and cancelling the other (slower) calculations. Typically used to run several different calculations in parallel, all of which are supposed to give the same result, but may last different amount of time each. If the system has enough threads available, the calculations can be test-run in parallel and the fastest result is then used, while the other results are cancelled or discarded.
Parameters:
alternatives - All the functions to invoke in parallel
Returns:
The fastest result obtained


withExistingPool

static java.lang.Object withExistingPool(java.util.concurrent.ExecutorService pool, groovy.lang.Closure cl)
Creates a new instance of ExecutorService, binds it to the current thread, enables the ExecutorService DSL and runs the supplied closure. Within the supplied code block the ExecutorService is available as the only parameter, objects have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsExecutorsPoolUtil category class as well as closures can be turned into asynchronous ones by calling the async() method on them. E.g. closure,async returns a new closure, which, when run will schedule the original closure for processing in the pool. Calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel.
 def result = new ConcurrentSkipListSet()
 GParsExecutorsPool.withPool(5) {ExecutorService service ->
     [1, 2, 3, 4, 5].eachParallel{Number number -> result.add(number * 10)}*     assertEquals(new HashSet([10, 20, 30, 40, 50]), result)
}* 
Parameters:
pool - The ExecutorService to use, the service will not be shutdown after this method returns


withPool

static java.lang.Object withPool(groovy.lang.Closure cl)
Creates a new instance of ExecutorService, binds it to the current thread, enables the ExecutorService DSL and runs the supplied closure. It is an identical alternative for withPool() with a shorter name. Within the supplied code block the ExecutorService is available as the only parameter, objects have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsExecutorsPoolUtil category class as well as closures can be turned into asynchronous ones by calling the async() method on them. E.g. closure,async returns a new closure, which, when run will schedule the original closure for processing in the pool. Calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel.
 def result = new ConcurrentSkipListSet()
 GParsExecutorsPool.withPool {ExecutorService service ->
     [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 java.lang.Object withPool(int numberOfThreads, groovy.lang.Closure cl)
Creates a new instance of ExecutorService, binds it to the current thread, enables the ExecutorService DSL and runs the supplied closure. It is an identical alternative for withPool() with a shorter name. Within the supplied code block the ExecutorService is available as the only parameter, objects have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsExecutorsPoolUtil category class as well as closures can be turned into asynchronous ones by calling the async() method on them. E.g. closure,async returns a new closure, which, when run will schedule the original closure for processing in the pool. Calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel.
 def result = new ConcurrentSkipListSet()
 GParsExecutorsPool.withPool(5) {ExecutorService service ->
     [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 java.lang.Object withPool(int numberOfThreads, java.util.concurrent.ThreadFactory threadFactory, groovy.lang.Closure cl)
Creates a new instance of ExecutorService, binds it to the current thread, enables the ExecutorService DSL and runs the supplied closure. It is an identical alternative for withPool() with a shorter name. Within the supplied code block the ExecutorService is available as the only parameter, objects have been enhanced with the eachParallel(), collectParallel() and other methods from the GParsExecutorsPoolUtil category class as well as closures can be turned into asynchronous ones by calling the async() method on them. E.g. closure,async returns a new closure, which, when run will schedule the original closure for processing in the pool. Calling images.eachParallel{processImage(it}} will call the potentially long-lasting processImage() operation on each image in the images collection in parallel.
 def result = new ConcurrentSkipListSet()
 GParsExecutorsPool.withPool(5) {ExecutorService service ->
     [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
threadFactory - Factory for threads in the pool
cl - The block of code to invoke with the DSL enabled


 

Copyright © 2008–2010 Václav Pech. All Rights Reserved.