more consistent interrupt state restoration

Author: inponomarev

src/main/java/org/apache/commons/lang3/ThreadUtils.java

@@ -519,7 +519,8 @@ public static void sleepQuietly(final Duration duration) {
         try {
             sleep(duration);
         } catch (final InterruptedException ignore) {
-            // Ignore & be quiet.
+            // Restore interrupted state, ignore & be quiet.
+            Thread.currentThread().interrupt();
         }
     }
 

src/main/java/org/apache/commons/lang3/concurrent/BackgroundInitializer.java

@@ -345,7 +345,11 @@ public synchronized boolean isInitialized() {
         try {
             future.get();
             return true;
-        } catch (CancellationException | ExecutionException | InterruptedException e) {
+        } catch (CancellationException | ExecutionException e) {
+            return false;
+        } catch (InterruptedException e) {
+            // reset interrupted state
+            Thread.currentThread().interrupt();
             return false;
         }
     }

src/test/java/org/apache/commons/lang3/ThreadUtilsTest.java

@@ -36,6 +36,9 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Predicate;
 
 import org.apache.commons.lang3.ThreadUtils.ThreadGroupPredicate;
@@ -421,4 +424,26 @@ void testThreadsSameName() throws InterruptedException {
         }
     }
 
+
+    @Test
+    void sleepQuietly() throws Exception {
+        CountDownLatch started = new CountDownLatch(1);
+        AtomicBoolean interruptedAfter = new AtomicBoolean(false);
+        AtomicReference<Throwable> thrown = new AtomicReference<>();
+        Thread worker = new Thread(() -> {
+            started.countDown();
+            try {
+                ThreadUtils.sleepQuietly(Duration.ofDays(1)); // should be cut short by interrupt
+                interruptedAfter.set(Thread.currentThread().isInterrupted());
+            } catch (Throwable t) {
+                thrown.set(t);
+            }
+        });
+        worker.start();
+        assertTrue(started.await(2, TimeUnit.SECONDS), "Worker did not start in time");
+        worker.interrupt();
+        worker.join();
+        assertNull(thrown.get());
+        assertTrue(interruptedAfter.get());
+    }
 }