    001    /*
    002     * Copyright (C) 2006 The Guava Authors
    003     *
    004     * Licensed under the Apache License, Version 2.0 (the "License");
    005     * you may not use this file except in compliance with the License.
    006     * You may obtain a copy of the License at
    007     *
    008     * http://www.apache.org/licenses/LICENSE-2.0
    009     *
    010     * Unless required by applicable law or agreed to in writing, software
    011     * distributed under the License is distributed on an "AS IS" BASIS,
    012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    013     * See the License for the specific language governing permissions and
    014     * limitations under the License.
    015     */
    016
    017    package com.google.common.util.concurrent;
    018
    019    import static com.google.common.base.Preconditions.checkArgument;
    020    import static com.google.common.base.Preconditions.checkNotNull;
    021
    022    import com.google.common.annotations.Beta;
    023    import com.google.common.collect.ObjectArrays;
    024    import com.google.common.collect.Sets;
    025
    026    import java.lang.reflect.InvocationHandler;
    027    import java.lang.reflect.InvocationTargetException;
    028    import java.lang.reflect.Method;
    029    import java.lang.reflect.Proxy;
    030    import java.util.Set;
    031    import java.util.concurrent.Callable;
    032    import java.util.concurrent.ExecutionException;
    033    import java.util.concurrent.ExecutorService;
    034    import java.util.concurrent.Executors;
    035    import java.util.concurrent.Future;
    036    import java.util.concurrent.TimeUnit;
    037    import java.util.concurrent.TimeoutException;
    038
    039    /**
    040     * A TimeLimiter that runs method calls in the background using an
    041     * {@link ExecutorService}.  If the time limit expires for a given method call,
    042     * the thread running the call will be interrupted.
    043     *
    044     * @author Kevin Bourrillion
    045     * @since 1.0
    046     */
    047    @Beta
    048    public final class SimpleTimeLimiter implements TimeLimiter {
    049
    050      private final ExecutorService executor;
    051
    052      /**
    053       * Constructs a TimeLimiter instance using the given executor service to
    054       * execute proxied method calls.
    055       * <p>
    056       * <b>Warning:</b> using a bounded executor
    057       * may be counterproductive!  If the thread pool fills up, any time callers
    058       * spend waiting for a thread may count toward their time limit, and in
    059       * this case the call may even time out before the target method is ever
    060       * invoked.
    061       *
    062       * @param executor the ExecutorService that will execute the method calls on
    063       *     the target objects; for example, a {@link
    064       *     Executors#newCachedThreadPool()}.
    065       */
    066      public SimpleTimeLimiter(ExecutorService executor) {
    067        this.executor = checkNotNull(executor);
    068      }
    069
    070      /**
    071       * Constructs a TimeLimiter instance using a {@link
    072       * Executors#newCachedThreadPool()} to execute proxied method calls.
    073       *
    074       * <p><b>Warning:</b> using a bounded executor may be counterproductive! If
    075       * the thread pool fills up, any time callers spend waiting for a thread may
    076       * count toward their time limit, and in this case the call may even time out
    077       * before the target method is ever invoked.
    078       */
    079      public SimpleTimeLimiter() {
    080        this(Executors.newCachedThreadPool());
    081      }
    082
    083      @Override
    084      public <T> T newProxy(final T target, Class<T> interfaceType,
    085          final long timeoutDuration, final TimeUnit timeoutUnit) {
    086        checkNotNull(target);
    087        checkNotNull(interfaceType);
    088        checkNotNull(timeoutUnit);
    089        checkArgument(timeoutDuration > 0, "bad timeout: " + timeoutDuration);
    090        checkArgument(interfaceType.isInterface(),
    091            "interfaceType must be an interface type");
    092
    093        final Set<Method> interruptibleMethods
    094            = findInterruptibleMethods(interfaceType);
    095
    096        InvocationHandler handler = new InvocationHandler() {
    097          @Override
    098          public Object invoke(Object obj, final Method method, final Object[] args)
    099              throws Throwable {
    100            Callable<Object> callable = new Callable<Object>() {
    101              @Override
    102              public Object call() throws Exception {
    103                try {
    104                  return method.invoke(target, args);
    105                } catch (InvocationTargetException e) {
    106                  throwCause(e, false);
    107                  throw new AssertionError("can't get here");
    108                }
    109              }
    110            };
    111            return callWithTimeout(callable, timeoutDuration, timeoutUnit,
    112                interruptibleMethods.contains(method));
    113          }
    114        };
    115        return newProxy(interfaceType, handler);
    116      }
    117
    118      // TODO: should this actually throw only ExecutionException?
    119      @Override
    120      public <T> T callWithTimeout(Callable<T> callable, long timeoutDuration,
    121          TimeUnit timeoutUnit, boolean amInterruptible) throws Exception {
    122        checkNotNull(callable);
    123        checkNotNull(timeoutUnit);
    124        checkArgument(timeoutDuration > 0, "timeout must be positive: %s",
    125            timeoutDuration);
    126        Future<T> future = executor.submit(callable);
    127        try {
    128          if (amInterruptible) {
    129            try {
    130              return future.get(timeoutDuration, timeoutUnit);
    131            } catch (InterruptedException e) {
    132              future.cancel(true);
    133              throw e;
    134            }
    135          } else {
    136            return Uninterruptibles.getUninterruptibly(future,
    137                timeoutDuration, timeoutUnit);
    138          }
    139        } catch (ExecutionException e) {
    140          throw throwCause(e, true);
    141        } catch (TimeoutException e) {
    142          future.cancel(true);
    143          throw new UncheckedTimeoutException(e);
    144        }
    145      }
    146
    147      private static Exception throwCause(Exception e, boolean combineStackTraces)
    148          throws Exception {
    149        Throwable cause = e.getCause();
    150        if (cause == null) {
    151          throw e;
    152        }
    153        if (combineStackTraces) {
    154          StackTraceElement[] combined = ObjectArrays.concat(cause.getStackTrace(),
    155              e.getStackTrace(), StackTraceElement.class);
    156          cause.setStackTrace(combined);
    157        }
    158        if (cause instanceof Exception) {
    159          throw (Exception) cause;
    160        }
    161        if (cause instanceof Error) {
    162          throw (Error) cause;
    163        }
    164        // The cause is a weird kind of Throwable, so throw the outer exception.
    165        throw e;
    166      }
    167
    168      private static Set<Method> findInterruptibleMethods(Class<?> interfaceType) {
    169        Set<Method> set = Sets.newHashSet();
    170        for (Method m : interfaceType.getMethods()) {
    171          if (declaresInterruptedEx(m)) {
    172            set.add(m);
    173          }
    174        }
    175        return set;
    176      }
    177
    178      private static boolean declaresInterruptedEx(Method method) {
    179        for (Class<?> exType : method.getExceptionTypes()) {
    180          // debate: == or isAssignableFrom?
    181          if (exType == InterruptedException.class) {
    182            return true;
    183          }
    184        }
    185        return false;
    186      }
    187
    188      // TODO: replace with version in common.reflect if and when it's open-sourced
    189      private static <T> T newProxy(
    190          Class<T> interfaceType, InvocationHandler handler) {
    191        Object object = Proxy.newProxyInstance(interfaceType.getClassLoader(),
    192            new Class<?>[] { interfaceType }, handler);
    193        return interfaceType.cast(object);
    194      }
    195    }