groovyx.gpars
[Groovy] Class GParsExecutorsPool

java.lang.Object
  groovyx.gpars.GParsExecutorsPool

class GParsExecutorsPool

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

currentPoolStack

private static ThreadLocalPools currentPoolStack

Maps threads to their appropriate thread pools

defaultPoolSize

private static final int defaultPoolSize

Caches the default pool size.

GParsExecutorsPool

GParsExecutorsPool()

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.

shutdown

static final void shutdown()

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–2013 Václav Pech. All Rights Reserved.