Field Detail

• private static ThreadLocalPools currentPoolStack

  Maps threads to their appropriate thread pools

• private static final int defaultPoolSize

  Caches the default pool size.

Constructor Detail

• GParsPool()

Method Detail

• private static UncaughtExceptionHandler createDefaultUncaughtExceptionHandler()

• 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, UncaughtExceptionHandler handler)

• static java.lang.Object ensurePool(java.util.concurrent.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.

• static java.util.List<java.util.concurrent.Future<java.lang.Object>> 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

• static java.util.List<java.util.concurrent.Future<java.lang.Object>> executeAsync(java.util.List<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

• static java.util.List<java.lang.Object> 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

• static java.util.List<java.lang.Object> executeAsyncAndWait(java.util.List<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

• protected static java.lang.Object retrieveCurrentPool()

  Retrieves the pool assigned to the current thread.

• static T runForkJoin(AbstractForkJoinWorker<T> rootWorker)

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

  Returns:

  The result of the whole calculation

  Parameters:

  rootWorker - The worker that calculates the root of the Fork/Join problem

• static T runForkJoin(java.lang.Object... args)

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

  Returns:

  The result of the whole calculation

  Parameters:

  rootWorker - The worker that calculates the root of the Fork/Join problem

• static final void shutdown()

• static java.lang.Object speculate(java.util.List<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.

  Returns:

  The fastest result obtained

  Parameters:

  alternatives - All the functions to invoke in parallel

• 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.

  Returns:

  The fastest result obtained

  Parameters:

  alternatives - All the functions to invoke in parallel

• static java.lang.Object withExistingPool(java.util.concurrent.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

• static java.lang.Object 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

• static java.lang.Object 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

• static java.lang.Object 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