don't remove uninterruptibly() just yet

Author: fluentfuture

mug/src/main/java/com/google/mu/util/concurrent/Fanout.java

@@ -230,6 +230,174 @@ public static void concurrently(Runnable task1, Runnable task2, Runnable... more
     new Scope().add(task1, task2).add(moreTasks).run();
   }
 
+  /**
+   * Runs {@code a} and {@code b} concurrently and <em>uninterruptibly</em> in their own virtual
+   * threads. After all of the concurrent operations return successfully, invoke the {@code join}
+   * function on the results in the caller's thread.
+   *
+   * <p>For example:
+   *
+   * <pre>{@code
+   * Result result = uninterruptibly(
+   *   () -> fetchArm(),
+   *   () -> fetchLeg(),
+   *   (arm, leg) -> new Result(arm, leg));
+   * }</pre>
+   *
+   * @throws RuntimeException wrapping the original exception from the virtual thread if
+   *     any concurrent operation failed
+   * @throws X thrown by the {@code join} function
+   * @deprecated prefer using the concurrently() overloads that allow cancellation
+   */
+  @Deprecated
+  public static <A, B, R, X extends Throwable> R uninterruptibly(
+      Supplier<A> a, Supplier<B> b, Join2<? super A, ? super B, R, X> join)
+      throws X {
+    requireNonNull(join);
+    Scope scope = new Scope();
+    AtomicReference<A> r1 = scope.add(a);
+    AtomicReference<B> r2 = scope.add(b);
+    scope.runUninterruptibly();
+    return join.join(r1.get(), r2.get());
+  }
+
+  /**
+   * Runs {@code a}, {@code b} and {@code c} concurrently and <em>uninterruptibly</em> in their own
+   * virtual threads. After all of the concurrent operations return successfully, invoke the {@code
+   * join} function on the results in the caller's thread.
+   *
+   * <p>For example:
+   *
+   * <pre>{@code
+   * Result result = uninterruptibly(
+   *   () -> fetchHead(),
+   *   () -> fetchArm(),
+   *   () -> fetchLeg(),
+   *   (head, arm, leg) -> new Result(head, arm, leg));
+   * }</pre>
+   *
+   * @throws RuntimeException wrapping the original exception from the virtual thread if
+   *     any concurrent operation failed
+   * @throws X thrown by the {@code join} function
+   * @deprecated prefer using the concurrently() overloads that allow cancellation
+   */
+  @Deprecated
+  public static <A, B, C, R, X extends Throwable> R uninterruptibly(
+      Supplier<A> a,
+      Supplier<B> b,
+      Supplier<C> c,
+      Join3<? super A, ? super B, ? super C, R, X> join)
+      throws X {
+    requireNonNull(join);
+    Scope scope = new Scope();
+    AtomicReference<A> r1 = scope.add(a);
+    AtomicReference<B> r2 = scope.add(b);
+    AtomicReference<C> r3 = scope.add(c);
+    scope.runUninterruptibly();
+    return join.join(r1.get(), r2.get(), r3.get());
+  }
+
+  /**
+   * Runs {@code a}, {@code b}, {@code c} and {@code d} concurrently and <em>uninterruptibly</em> in
+   * their own virtual threads. After all of the concurrent operations return successfully, invoke
+   * the {@code join} function on the results in the caller's thread.
+   *
+   * <p>For example:
+   *
+   * <pre>{@code
+   * Result result = uninterruptibly(
+   *   () -> fetchHead(),
+   *   () -> fetchShoulder(),
+   *   () -> fetchArm(),
+   *   () -> fetchLeg(),
+   *   (head, shoulder, arm, leg) -> new Result(head, shoulder, arm, leg));
+   * }</pre>
+   *
+   * @throws RuntimeException wrapping the original exception from the virtual thread if
+   *     any concurrent operation failed
+   * @throws X thrown by the {@code join} function
+   * @deprecated prefer using the concurrently() overloads that allow cancellation
+   */
+  @Deprecated
+  public static <A, B, C, D, R, X extends Throwable> R uninterruptibly(
+      Supplier<A> a,
+      Supplier<B> b,
+      Supplier<C> c,
+      Supplier<D> d,
+      Join4<? super A, ? super B, ? super C, ? super D, R, X> join)
+      throws X {
+    requireNonNull(join);
+    Scope scope = new Scope();
+    AtomicReference<A> r1 = scope.add(a);
+    AtomicReference<B> r2 = scope.add(b);
+    AtomicReference<C> r3 = scope.add(c);
+    AtomicReference<D> r4 = scope.add(d);
+    scope.runUninterruptibly();
+    return join.join(r1.get(), r2.get(), r3.get(), r4.get());
+  }
+
+  /**
+   * Runs {@code a}, {@code b}, {@code c}, {@code d} and {@code e} concurrently and
+   * <em>uninterruptibly<em> in their own virtual threads. After all of the concurrent operations
+   * return successfully, invoke the {@code join} function on the results in the caller's thread.
+   *
+   * <p>For example:
+   *
+   * <pre>{@code
+   * Result result = uninterruptibly(
+   *   () -> fetchHead(),
+   *   () -> fetchShoulder(),
+   *   () -> fetchArm(),
+   *   () -> fetchLeg(),
+   *   () -> fetchFeet(),
+   *   (head, shoulder, arm, leg, feet) -> new Result(head, shoulder, arm, leg, feet));
+   * }</pre>
+   *
+   * @throws RuntimeException wrapping the original exception from the virtual thread if
+   *     any concurrent operation failed
+   * @throws X thrown by the {@code join} function
+   * @deprecated prefer using the concurrently() overloads that allow cancellation
+   */
+  @Deprecated
+  public static <A, B, C, D, E, R, X extends Throwable> R uninterruptibly(
+      Supplier<A> a,
+      Supplier<B> b,
+      Supplier<C> c,
+      Supplier<D> d,
+      Supplier<E> e,
+      Join5<? super A, ? super B, ? super C, ? super D, ? super E, R, X> join)
+      throws X {
+    requireNonNull(join);
+    Scope scope = new Scope();
+    AtomicReference<A> r1 = scope.add(a);
+    AtomicReference<B> r2 = scope.add(b);
+    AtomicReference<C> r3 = scope.add(c);
+    AtomicReference<D> r4 = scope.add(d);
+    AtomicReference<E> r5 = scope.add(e);
+    scope.runUninterruptibly();
+    return join.join(r1.get(), r2.get(), r3.get(), r4.get(), r5.get());
+  }
+
+  /**
+   * Runs {@code task1}, {@code task2} and {@code moreTasks} concurrently and
+   * <em>uninterruptibly<em> in their own virtual threads.
+   *
+   * <p>For example:
+   *
+   * <pre>{@code
+   * uninterruptibly(() -> uploadFile(), () -> sendMessageToQueue());
+   * }</pre>
+   *
+   * @throws RuntimeException wrapping the original exception from the virtual thread if
+   *     any concurrent operation failed
+   * @since 8.3
+   * @deprecated prefer using the concurrently() overloads that allow cancellation
+   */
+  @Deprecated
+  public static void uninterruptibly(Runnable task1, Runnable task2, Runnable... moreTasks) {
+    new Scope().add(task1, task2).add(moreTasks).runUninterruptibly();
+  }
+
   /**
    * Returns a concurrency-limited {@link Parallelizer} that can be used to run a potentially large
    * number of fanout concurrent tasks using the currently configured standard (virtual thread)
@@ -319,6 +487,13 @@ void run() throws StructuredConcurrencyInterruptedException {
         throw new StructuredConcurrencyInterruptedException(e);
       }
     }
+
+    @Deprecated
+    void runUninterruptibly() {
+      try (Completion completion = new Completion()) {
+        withUnlimitedConcurrency().parallelizeUninterruptibly(runnables.stream().map(completion::toRun));
+      }
+    }
   }
 
   private static StructuredConcurrencyExecutorPlugin loadExecutorPlugin() {

mug/src/test/java/com/google/mu/util/concurrent/FanoutTest.java

@@ -3,6 +3,7 @@
 
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.mu.util.concurrent.Fanout.concurrently;
+import static com.google.mu.util.concurrent.Fanout.uninterruptibly;
 import static com.google.mu.util.concurrent.Fanout.withMaxConcurrency;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertThrows;