Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.util.concurrent;
 
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
 
Utilities for treating interruptible operations as uninterruptible. In all cases, if a thread is interrupted during such a call, the call continues to block until the result is available or the timeout elapses, and only then re-interrupts the thread.

Author(s):
Anthony Zana
Since:
10.0
 
 public final class Uninterruptibles {
 
   // Implementation Note: As of 3-7-11, the logic for each blocking/timeout
   // methods is identical, save for method being invoked.
 
  
Invokes latch.await() uninterruptibly.
 
   public static void awaitUninterruptibly(CountDownLatch latch) {
     boolean interrupted = false;
     try {
       while (true) {
         try {
           latch.await();
           return;
         } catch (InterruptedException e) {
           interrupted = true;
         }
       }
     } finally {
       if (interrupted) {
         Thread.currentThread().interrupt();
       }
     }
   }

  
Invokes latch. await(timeout, unit) uninterruptibly.
 
   public static boolean awaitUninterruptibly(CountDownLatch latch,
       long timeoutTimeUnit unit) {
     boolean interrupted = false;
     try {
       long remainingNanos = unit.toNanos(timeout);
       long end = System.nanoTime() + remainingNanos;
 
       while (true) {
         try {
           // CountDownLatch treats negative timeouts just like zero.
           return latch.await(remainingNanos);
         } catch (InterruptedException e) {
           interrupted = true;
           remainingNanos = end - System.nanoTime();
         }
       }
     } finally {
       if (interrupted) {
         Thread.currentThread().interrupt();
       }
     }
   }

  
Invokes toJoin.join() uninterruptibly.
 
   public static void joinUninterruptibly(Thread toJoin) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          toJoin.join();
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  
Invokes future.get() uninterruptibly. To get uninterruptibility and remove checked exceptions, see Futures.getUnchecked(java.util.concurrent.Future).

If instead, you wish to treat java.lang.InterruptedException uniformly with other exceptions, see Futures.get or Futures.makeChecked(com.google.common.util.concurrent.ListenableFuture,com.google.common.base.Function).

Throws:
java.util.concurrent.ExecutionException if the computation threw an exception
CancellationException if the computation was cancelled
  public static <V> V getUninterruptibly(Future<V> future)
      throws ExecutionException {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          return future.get();
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  
Invokes future.get(timeout, unit) uninterruptibly.

If instead, you wish to treat java.lang.InterruptedException uniformly with other exceptions, see Futures.get or Futures.makeChecked(com.google.common.util.concurrent.ListenableFuture,com.google.common.base.Function).

Throws:
java.util.concurrent.ExecutionException if the computation threw an exception
CancellationException if the computation was cancelled
java.util.concurrent.TimeoutException if the wait timed out
  public static <V> V getUninterruptibly(
      Future<V> futurelong timeout,  TimeUnit unit)
          throws ExecutionExceptionTimeoutException {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);
      long end = System.nanoTime() + remainingNanos;
      while (true) {
        try {
          // Future treats negative timeouts just like zero.
          return future.get(remainingNanos);
        } catch (InterruptedException e) {
          interrupted = true;
          remainingNanos = end - System.nanoTime();
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  
Invokes unit. timedJoin(toJoin, timeout) uninterruptibly.
  public static void joinUninterruptibly(Thread toJoin,
      long timeoutTimeUnit unit) {
    Preconditions.checkNotNull(toJoin);
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);
      long end = System.nanoTime() + remainingNanos;
      while (true) {
        try {
          // TimeUnit.timedJoin() treats negative timeouts just like zero.
          .timedJoin(toJoinremainingNanos);
          return;
        } catch (InterruptedException e) {
          interrupted = true;
          remainingNanos = end - System.nanoTime();
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  
Invokes queue.take() uninterruptibly.
  public static <E> E takeUninterruptibly(BlockingQueue<E> queue) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          return queue.take();
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  
Invokes queue.put(element) uninterruptibly.

Throws:
java.lang.ClassCastException if the class of the specified element prevents it from being added to the given queue
java.lang.IllegalArgumentException if some property of the specified element prevents it from being added to the given queue
  public static <E> void putUninterruptibly(BlockingQueue<E> queue, E element) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          queue.put(element);
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }
  // TODO(user): Support Sleeper somehow (wrapper or interface method)?
  
Invokes unit.sleep(sleepFor) uninterruptibly.
  public static void sleepUninterruptibly(long sleepForTimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(sleepFor);
      long end = System.nanoTime() + remainingNanos;
      while (true) {
        try {
          // TimeUnit.sleep() treats negative timeouts just like zero.
          .sleep(remainingNanos);
          return;
        } catch (InterruptedException e) {
          interrupted = true;
          remainingNanos = end - System.nanoTime();
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }
  // TODO(user): Add support for waitUninterruptibly.
  private Uninterruptibles() {}
New to GrepCode? Check out our FAQ X