#1315 Add awaitTerminationUninterruptibly(..) for ExecutorService - M…

guava-tests/test/com/google/common/util/concurrent/UninterruptiblesTest.java

@@ -23,6 +23,7 @@
 import static com.google.common.util.concurrent.Uninterruptibles.takeUninterruptibly;
 import static com.google.common.util.concurrent.Uninterruptibles.tryAcquireUninterruptibly;
 import static com.google.common.util.concurrent.Uninterruptibles.tryLockUninterruptibly;
+import static com.google.common.util.concurrent.Uninterruptibles.awaitTerminationUninterruptibly;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.SECONDS;
 
@@ -465,6 +466,41 @@ public void testTryAcquireTimeoutMultiInterruptExpiredMultiPermit() {
     assertInterrupted();
   }
 
+  // executor.awaitTermination Testcases
+  public void testTryAwaitTerminationUninterruptibly() {
+      ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(1);
+      requestInterruptIn(500);
+      scheduledPool.execute(new Runnable() {
+        public void run() {
+          try {
+            Thread.sleep(1000);
+          } catch (InterruptedException e) {
+            e.printStackTrace();
+          }
+        }
+      });
+	  scheduledPool.shutdown();
+      awaitTerminationUninterruptibly(scheduledPool, LONG_DELAY_MS, MILLISECONDS);
+      assertInterrupted();
+  }
+
+  public void testTryAwaitTerminationInfiniteTimeout() {
+      ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(1);
+      requestInterruptIn(500);
+      scheduledPool.execute(new Runnable() {
+        public void run() {
+          try {
+            Thread.sleep(1000);
+          } catch (InterruptedException e) {
+            e.printStackTrace();
+          }
+        }
+      });
+	  scheduledPool.shutdown();
+      awaitTerminationUninterruptibly(scheduledPool);
+      assertInterrupted();
+  }
+
   /**
    * Wrapper around {@link Stopwatch} which also contains an "expected completion time." Creating a
    * {@code Completion} starts the underlying stopwatch.

guava/src/com/google/common/util/concurrent/Uninterruptibles.java

@@ -27,6 +27,7 @@
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
@@ -513,6 +514,45 @@ public static boolean tryLockUninterruptibly(Lock lock, long timeout, TimeUnit u
     }
   }
 
+  /** Invokes {@code queue.}{@link ExecutorService#awaitTermination(long, TimeUnit)} uninterruptibly. */
+  @GwtIncompatible // concurrency
+  @SuppressWarnings("GoodTime")
+  public static boolean awaitTerminationUninterruptibly(ExecutorService executor, long timeout, TimeUnit unit) {
+    boolean interrupted = false;
+    try {
+      long remainingNanos = unit.toNanos(timeout);
+      long end = System.nanoTime() + remainingNanos;
+      while (true) {
+        try {
+          return executor.awaitTermination(remainingNanos, unit);
+        } catch (InterruptedException e) {
+          interrupted = true;
+          remainingNanos = end - System.nanoTime();
+        }
+      }
+    } finally {
+      if (interrupted) {
+        Thread.currentThread().interrupt();
+      }
+    }
+  }
+
+  /**
+   * Invokes {@code queue.}{@link ExecutorService#awaitTermination(long, TimeUnit)} uninterruptibly.
+   * Infinite timeout version.
+   */
+  @GwtIncompatible // concurrency
+  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
+  public static boolean awaitTerminationUninterruptibly(ExecutorService executor) {
+    boolean interrupted = false;
+    while (true) {
+      interrupted = awaitTerminationUninterruptibly(executor, Long.MAX_VALUE, TimeUnit.NANOSECONDS);
+      if(interrupted) {
+        return interrupted;
+      }
+    }
+  }
+
   // TODO(user): Add support for waitUninterruptibly.
 
   private Uninterruptibles() {}