common/util/src/main/java/org/opendaylight/yangtools/util/ExecutorServiceUtil.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.util;
   9
  10 import com.google.common.util.concurrent.ForwardingBlockingQueue;
  11 import java.util.concurrent.BlockingQueue;
  12 import java.util.concurrent.ExecutorService;
  13 import java.util.concurrent.RejectedExecutionException;
  14 import java.util.concurrent.RejectedExecutionHandler;
  15 import java.util.concurrent.ThreadPoolExecutor;
  16 import java.util.concurrent.TimeUnit;
  17 import org.eclipse.jdt.annotation.NonNull;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20
  21 /**
  22  * Utility methods for dealing with {@link ExecutorService}s.
  23  */
  24 public final class ExecutorServiceUtil {
  25     private static final class WaitInQueueExecutionHandler implements RejectedExecutionHandler {
  26         @Override
  27         @SuppressWarnings("checkstyle:parameterName")
  28         public void rejectedExecution(final Runnable r, final ThreadPoolExecutor executor) {
  29             if (executor.isShutdown()) {
  30                 throw new RejectedExecutionException("Executor has been shutdown.");
  31             }
  32
  33             try {
  34                 executor.getQueue().put(r);
  35             } catch (InterruptedException e) {
  36                 LOG.debug("Interrupted while attempting to put to the queue", e);
  37                 throw new RejectedExecutionException("Interrupted while attempting to put to the queue", e);
  38             }
  39         }
  40     }
  41
  42     private static final Logger LOG = LoggerFactory.getLogger(ExecutorServiceUtil.class);
  43     private static final @NonNull RejectedExecutionHandler WAIT_IN_QUEUE_HANDLER = new WaitInQueueExecutionHandler();
  44
  45     private ExecutorServiceUtil() {
  46         // Hidden on purpose
  47     }
  48
  49     /**
  50      * Creates a {@link BlockingQueue} which does not allow for non-blocking addition to the queue.
  51      * This is useful with {@link #waitInQueueExecutionHandler()} to turn force a
  52      * {@link ThreadPoolExecutor} to create as many threads as it is configured to before starting
  53      * to fill the queue.
  54      *
  55      * @param delegate Backing blocking queue.
  56      * @return A new blocking queue backed by the delegate
  57      */
  58     public static <E> @NonNull BlockingQueue<E> offerFailingBlockingQueue(final BlockingQueue<E> delegate) {
  59         return new ForwardingBlockingQueue<>() {
  60             @Override
  61             @SuppressWarnings("checkstyle:parameterName")
  62             public boolean offer(final E o) {
  63                 return false;
  64             }
  65
  66             @Override
  67             protected BlockingQueue<E> delegate() {
  68                 return delegate;
  69             }
  70         };
  71     }
  72
  73     /**
  74      * Returns a {@link RejectedExecutionHandler} which blocks on the {@link ThreadPoolExecutor}'s
  75      * backing queue if a new thread cannot be spawned.
  76      *
  77      * @return A shared RejectedExecutionHandler instance.
  78      */
  79     public static @NonNull RejectedExecutionHandler waitInQueueExecutionHandler() {
  80         return WAIT_IN_QUEUE_HANDLER;
  81     }
  82
  83     /**
  84      * Tries to shutdown the given executor gracefully by awaiting termination for the given
  85      * timeout period. If the timeout elapses before termination, the executor is forcefully
  86      * shutdown.
  87      */
  88     public static void tryGracefulShutdown(final @NonNull ExecutorService executor, final long timeout,
  89             final @NonNull TimeUnit unit) {
  90         executor.shutdown();
  91
  92         try {
  93             if (!executor.awaitTermination(timeout, unit)) {
  94                 executor.shutdownNow();
  95             }
  96         } catch (InterruptedException e) {
  97             executor.shutdownNow();
  98         }
  99     }
 100 }