Package com.google.common.util.concurrent

Class SimpleTimeLimiter

  • All Implemented Interfaces:
    TimeLimiter
    public final class SimpleTimeLimiter
extends java.lang.Object
implements TimeLimiter
    A TimeLimiter that runs method calls in the background using an ExecutorService. If the time limit expires for a given method call, the thread running the call will be interrupted.
    Since:
    1.0

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private java.util.concurrent.ExecutorService executor  

    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private SimpleTimeLimiter​(java.util.concurrent.ExecutorService executor)  

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      <T> T callUninterruptiblyWithTimeout​(java.util.concurrent.Callable<T> callable, long timeoutDuration, java.util.concurrent.TimeUnit timeoutUnit)
      Invokes a specified Callable, timing out after the specified time limit.
      <T> T callWithTimeout​(java.util.concurrent.Callable<T> callable, long timeoutDuration, java.util.concurrent.TimeUnit timeoutUnit)
      Invokes a specified Callable, timing out after the specified time limit.
      private <T> T callWithTimeout​(java.util.concurrent.Callable<T> callable, long timeoutDuration, java.util.concurrent.TimeUnit timeoutUnit, boolean amInterruptible)  
      private static void checkPositiveTimeout​(long timeoutDuration)  
      static SimpleTimeLimiter create​(java.util.concurrent.ExecutorService executor)
      Creates a TimeLimiter instance using the given executor service to execute method calls.
      private static boolean declaresInterruptedEx​(java.lang.reflect.Method method)  
      private static java.util.Set<java.lang.reflect.Method> findInterruptibleMethods​(java.lang.Class<?> interfaceType)  
      private static <T> T newProxy​(java.lang.Class<T> interfaceType, java.lang.reflect.InvocationHandler handler)  
      <T> T newProxy​(T target, java.lang.Class<T> interfaceType, long timeoutDuration, java.util.concurrent.TimeUnit timeoutUnit)
      Returns an instance of interfaceType that delegates all method calls to the target object, enforcing the specified time limit on each call.
      void runUninterruptiblyWithTimeout​(java.lang.Runnable runnable, long timeoutDuration, java.util.concurrent.TimeUnit timeoutUnit)
      Invokes a specified Runnable, timing out after the specified time limit.
      void runWithTimeout​(java.lang.Runnable runnable, long timeoutDuration, java.util.concurrent.TimeUnit timeoutUnit)
      Invokes a specified Runnable, timing out after the specified time limit.
      private static java.lang.Exception throwCause​(java.lang.Exception e, boolean combineStackTraces)  
      private void wrapAndThrowExecutionExceptionOrError​(java.lang.Throwable cause)  
      private void wrapAndThrowRuntimeExecutionExceptionOrError​(java.lang.Throwable cause)  

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Field Detail

      • executor

        private final java.util.concurrent.ExecutorService executor

    • Constructor Detail

      • SimpleTimeLimiter

        private SimpleTimeLimiter​(java.util.concurrent.ExecutorService executor)

    • Method Detail

      • create

        public static SimpleTimeLimiter create​(java.util.concurrent.ExecutorService executor)
        Creates a TimeLimiter instance using the given executor service to execute method calls.

        Warning: using a bounded executor may be counterproductive! If the thread pool fills up, any time callers spend waiting for a thread may count toward their time limit, and in this case the call may even time out before the target method is ever invoked.

        Parameters:
        executor - the ExecutorService that will execute the method calls on the target objects; for example, a Executors.newCachedThreadPool().
        Since:
        22.0

      • newProxy

        public <T> T newProxy​(T target,
                      java.lang.Class<T> interfaceType,
                      long timeoutDuration,
                      java.util.concurrent.TimeUnit timeoutUnit)
        Description copied from interface: TimeLimiter
        Returns an instance of interfaceType that delegates all method calls to the target object, enforcing the specified time limit on each call. This time-limited delegation is also performed for calls to Object.equals(java.lang.Object), Object.hashCode(), and Object.toString().

        If the target method call finishes before the limit is reached, the return value or exception is propagated to the caller exactly as-is. If, on the other hand, the time limit is reached, the proxy will attempt to abort the call to the target, and will throw an UncheckedTimeoutException to the caller.

        It is important to note that the primary purpose of the proxy object is to return control to the caller when the timeout elapses; aborting the target method call is of secondary concern. The particular nature and strength of the guarantees made by the proxy is implementation-dependent. However, it is important that each of the methods on the target object behaves appropriately when its thread is interrupted.

        For example, to return the value of target.someMethod(), but substitute DEFAULT_VALUE if this method call takes over 50 ms, you can use this code: 

           TimeLimiter limiter = . . .;
   TargetType proxy = limiter.newProxy(
       target, TargetType.class, 50, TimeUnit.MILLISECONDS);
   try {
     return proxy.someMethod();
   } catch (UncheckedTimeoutException e) {
     return DEFAULT_VALUE;
   }
        Specified by:
        newProxy in interface TimeLimiter
        Parameters:
        target - the object to proxy
        interfaceType - the interface you wish the returned proxy to implement
        timeoutDuration - with timeoutUnit, the maximum length of time that callers are willing to wait on each method call to the proxy
        timeoutUnit - with timeoutDuration, the maximum length of time that callers are willing to wait on each method call to the proxy
        Returns:
        a time-limiting proxy

      • newProxy

        private static <T> T newProxy​(java.lang.Class<T> interfaceType,
                              java.lang.reflect.InvocationHandler handler)

      • callWithTimeout

        private <T> T callWithTimeout​(java.util.concurrent.Callable<T> callable,
                              long timeoutDuration,
                              java.util.concurrent.TimeUnit timeoutUnit,
                              boolean amInterruptible)
                       throws java.lang.Exception
        Throws:
        java.lang.Exception

      • callWithTimeout

        public <T> T callWithTimeout​(java.util.concurrent.Callable<T> callable,
                             long timeoutDuration,
                             java.util.concurrent.TimeUnit timeoutUnit)
                      throws java.util.concurrent.TimeoutException,
                             java.lang.InterruptedException,
                             java.util.concurrent.ExecutionException
        Description copied from interface: TimeLimiter
        Invokes a specified Callable, timing out after the specified time limit. If the target method call finishes before the limit is reached, the return value or a wrapped exception is propagated. If, on the other hand, the time limit is reached, we attempt to abort the call to the target, and throw a TimeoutException to the caller.
        Specified by:
        callWithTimeout in interface TimeLimiter
        Parameters:
        callable - the Callable to execute
        timeoutDuration - with timeoutUnit, the maximum length of time to wait
        timeoutUnit - with timeoutDuration, the maximum length of time to wait
        Returns:
        the result returned by the Callable
        Throws:
        java.util.concurrent.TimeoutException - if the time limit is reached
        java.lang.InterruptedException - if the current thread was interrupted during execution
        java.util.concurrent.ExecutionException - if callable throws a checked exception

      • callUninterruptiblyWithTimeout

        public <T> T callUninterruptiblyWithTimeout​(java.util.concurrent.Callable<T> callable,
                                            long timeoutDuration,
                                            java.util.concurrent.TimeUnit timeoutUnit)
                                     throws java.util.concurrent.TimeoutException,
                                            java.util.concurrent.ExecutionException
        Description copied from interface: TimeLimiter
        Invokes a specified Callable, timing out after the specified time limit. If the target method call finishes before the limit is reached, the return value or a wrapped exception is propagated. If, on the other hand, the time limit is reached, we attempt to abort the call to the target, and throw a TimeoutException to the caller.

        The difference with TimeLimiter.callWithTimeout(Callable, long, TimeUnit) is that this method will ignore interrupts on the current thread.

        Specified by:
        callUninterruptiblyWithTimeout in interface TimeLimiter
        Parameters:
        callable - the Callable to execute
        timeoutDuration - with timeoutUnit, the maximum length of time to wait
        timeoutUnit - with timeoutDuration, the maximum length of time to wait
        Returns:
        the result returned by the Callable
        Throws:
        java.util.concurrent.TimeoutException - if the time limit is reached
        java.util.concurrent.ExecutionException - if callable throws a checked exception

      • runWithTimeout

        public void runWithTimeout​(java.lang.Runnable runnable,
                           long timeoutDuration,
                           java.util.concurrent.TimeUnit timeoutUnit)
                    throws java.util.concurrent.TimeoutException,
                           java.lang.InterruptedException
        Description copied from interface: TimeLimiter
        Invokes a specified Runnable, timing out after the specified time limit. If the target method run finishes before the limit is reached, this method returns or a wrapped exception is propagated. If, on the other hand, the time limit is reached, we attempt to abort the run, and throw a TimeoutException to the caller.
        Specified by:
        runWithTimeout in interface TimeLimiter
        Parameters:
        runnable - the Runnable to execute
        timeoutDuration - with timeoutUnit, the maximum length of time to wait
        timeoutUnit - with timeoutDuration, the maximum length of time to wait
        Throws:
        java.util.concurrent.TimeoutException - if the time limit is reached
        java.lang.InterruptedException - if the current thread was interrupted during execution

      • runUninterruptiblyWithTimeout

        public void runUninterruptiblyWithTimeout​(java.lang.Runnable runnable,
                                          long timeoutDuration,
                                          java.util.concurrent.TimeUnit timeoutUnit)
                                   throws java.util.concurrent.TimeoutException
        Description copied from interface: TimeLimiter
        Invokes a specified Runnable, timing out after the specified time limit. If the target method run finishes before the limit is reached, this method returns or a wrapped exception is propagated. If, on the other hand, the time limit is reached, we attempt to abort the run, and throw a TimeoutException to the caller.

        The difference with TimeLimiter.runWithTimeout(Runnable, long, TimeUnit) is that this method will ignore interrupts on the current thread.

        Specified by:
        runUninterruptiblyWithTimeout in interface TimeLimiter
        Parameters:
        runnable - the Runnable to execute
        timeoutDuration - with timeoutUnit, the maximum length of time to wait
        timeoutUnit - with timeoutDuration, the maximum length of time to wait
        Throws:
        java.util.concurrent.TimeoutException - if the time limit is reached

      • throwCause

        private static java.lang.Exception throwCause​(java.lang.Exception e,
                                              boolean combineStackTraces)
                                       throws java.lang.Exception
        Throws:
        java.lang.Exception

      • findInterruptibleMethods

        private static java.util.Set<java.lang.reflect.Method> findInterruptibleMethods​(java.lang.Class<?> interfaceType)

      • declaresInterruptedEx

        private static boolean declaresInterruptedEx​(java.lang.reflect.Method method)

      • wrapAndThrowExecutionExceptionOrError

        private void wrapAndThrowExecutionExceptionOrError​(java.lang.Throwable cause)
                                            throws java.util.concurrent.ExecutionException
        Throws:
        java.util.concurrent.ExecutionException

      • wrapAndThrowRuntimeExecutionExceptionOrError

        private void wrapAndThrowRuntimeExecutionExceptionOrError​(java.lang.Throwable cause)

      • checkPositiveTimeout

        private static void checkPositiveTimeout​(long timeoutDuration)