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).

  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).

  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.
  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