Package groovy.concurrent

# Class ParallelScope

java.lang.Object
groovy.concurrent.ParallelScope

public final class ParallelScope extends Object
Convenience API for running work within a pool-isolated `AsyncScope`.

`ParallelScope` combines `Pool` and `AsyncScope` in a single call: the pool is created (or provided), used as the executor for the scope, and shut down when the scope exits.

This is the Groovy successor to GPars' `GParsPool.withPool` and `PGroup` scoping pattern, modernised for structured concurrency and virtual threads.

     // Groovy:
     ParallelScope.withPool(4) { scope ->
         def a = scope.async { cpuWork1() }
         def b = scope.async { cpuWork2() }
         [await(a), await(b)]
     }

     // With a pre-configured pool:
     def pool = Pool.cpu()
     ParallelScope.withPool(pool) { scope ->
         scope.async { work() }
         null
     }
     pool.close()

Since:
  6.0.0
See Also:
  - `Pool`
  - `AsyncScope`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static <T> T`
  `withPool(int threads, Function<AsyncScope,T> body)`
  Creates a fixed-size pool, executes the body within a scoped context, and shuts down the pool on exit.
  `static <T> T`
  `withPool(Pool pool, Function<AsyncScope,T> body)`
  Executes the body within a scope backed by the given pool.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Method Details

  - ### withPool

    public static <T> T withPool(int threads, Function<AsyncScope,T> body)
    Creates a fixed-size pool, executes the body within a scoped context, and shuts down the pool on exit.
    Type Parameters:
      `T` - the result type
    Parameters:
      `threads` - the number of threads in the pool
      `body` - the function receiving the scope
    Returns:
      the body's return value

  - ### withPool

    public static <T> T withPool(Pool pool, Function<AsyncScope,T> body)
    Executes the body within a scope backed by the given pool.

    The pool is not shut down on exit — the caller owns the pool's lifecycle. Both `AsyncScope.current()` and `Pool.current()` are bound for the duration.

    Type Parameters:
      `T` - the result type
    Parameters:
      `pool` - the pool to use as executor
      `body` - the function receiving the scope
    Returns:
      the body's return value