Java example source code file (TestingExecutors.java)

This example Java source code file (TestingExecutors.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

abstractfuture, abstractlisteningexecutorservice, beta, callable, gwtincompatible, listenablescheduledfuture, listeningscheduledexecutorservice, neverscheduledfuture, noopscheduledexecutorservice, override, runnable, samethreadscheduledexecutorservice, testingexecutors, threading, threads, timeunit, util

The TestingExecutors.java Java example source code

/*
 * Copyright (C) 2012 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.testing;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.collect.ImmutableList;
import com.google.common.primitives.Longs;
import com.google.common.util.concurrent.AbstractFuture;
import com.google.common.util.concurrent.AbstractListeningExecutorService;
import com.google.common.util.concurrent.ListenableScheduledFuture;
import com.google.common.util.concurrent.ListeningScheduledExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Delayed;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

/**
 * Factory methods for {@link ExecutorService} for testing.
 *
 * @author Chris Nokleberg
 * @since 14.0
 */
@Beta
@GwtIncompatible
public final class TestingExecutors {
  private TestingExecutors() {}

  /**
   * Returns a {@link ScheduledExecutorService} that never executes anything.
   *
   * <p>The {@code shutdownNow} method of the returned executor always returns an empty list despite
   * the fact that everything is still technically awaiting execution.
   * The {@code getDelay} method of any {@link ScheduledFuture} returned by the executor will always
   * return the max long value instead of the time until the user-specified delay.
   */
  public static ListeningScheduledExecutorService noOpScheduledExecutor() {
    return new NoOpScheduledExecutorService();
  }

  /**
   * Creates a scheduled executor service that runs each task in the thread
   * that invokes {@code execute/submit/schedule}, as in
   * {@link CallerRunsPolicy}. This applies both to individually submitted
   * tasks and to collections of tasks submitted via {@code invokeAll},
   * {@code invokeAny}, {@code schedule}, {@code scheduleAtFixedRate}, and
   * {@code scheduleWithFixedDelay}.  In the case of tasks submitted by
   * {@code invokeAll} or {@code invokeAny}, tasks will run serially on the
   * calling thread.  Tasks are run to completion before a {@code Future} is
   * returned to the caller (unless the executor has been shutdown).
   *
   * <p>The returned executor is backed by the executor returned by
   * {@link MoreExecutors#newDirectExecutorService} and subject to the same
   * constraints.
   *
   * <p>Although all tasks are immediately executed in the thread that
   * submitted the task, this {@code ExecutorService} imposes a small
   * locking overhead on each task submission in order to implement shutdown
   * and termination behavior.
   *
   * <p>Because of the nature of single-thread execution, the methods
   * {@code scheduleAtFixedRate} and {@code scheduleWithFixedDelay} are not
   * supported by this class and will throw an UnsupportedOperationException.
   *
   * <p>The implementation deviates from the {@code ExecutorService}
   * specification with regards to the {@code shutdownNow} method.  First,
   * "best-effort" with regards to canceling running tasks is implemented
   * as "no-effort".  No interrupts or other attempts are made to stop
   * threads executing tasks.  Second, the returned list will always be empty,
   * as any submitted task is considered to have started execution.
   * This applies also to tasks given to {@code invokeAll} or {@code invokeAny}
   * which are pending serial execution, even the subset of the tasks that
   * have not yet started execution.  It is unclear from the
   * {@code ExecutorService} specification if these should be included, and
   * it's much easier to implement the interpretation that they not be.
   * Finally, a call to {@code shutdown} or {@code shutdownNow} may result
   * in concurrent calls to {@code invokeAll/invokeAny} throwing
   * RejectedExecutionException, although a subset of the tasks may already
   * have been executed.
   *
   * @since 15.0
   */
  public static SameThreadScheduledExecutorService sameThreadScheduledExecutor() {
    return new SameThreadScheduledExecutorService();
  }

  private static final class NoOpScheduledExecutorService
      extends AbstractListeningExecutorService implements ListeningScheduledExecutorService {

    private volatile boolean shutdown;

    @Override public void shutdown() {
      shutdown = true;
    }

    @Override public List<Runnable> shutdownNow() {
      shutdown();
      return ImmutableList.of();
    }

    @Override public boolean isShutdown() {
      return shutdown;
    }

    @Override public boolean isTerminated() {
      return shutdown;
    }

    @Override public boolean awaitTermination(long timeout, TimeUnit unit) {
      return true;
    }

    @Override public void execute(Runnable runnable) {}

    @Override public <V> ListenableScheduledFuture schedule(
        Callable<V> callable, long delay, TimeUnit unit) {
      return NeverScheduledFuture.create();
    }

    @Override public ListenableScheduledFuture<?> schedule(
        Runnable command, long delay, TimeUnit unit) {
      return NeverScheduledFuture.create();
    }

    @Override public ListenableScheduledFuture<?> scheduleAtFixedRate(
        Runnable command, long initialDelay, long period, TimeUnit unit) {
      return NeverScheduledFuture.create();
    }

    @Override public ListenableScheduledFuture<?> scheduleWithFixedDelay(
        Runnable command, long initialDelay, long delay, TimeUnit unit) {
      return NeverScheduledFuture.create();
    }

    private static class NeverScheduledFuture<V>
        extends AbstractFuture<V> implements ListenableScheduledFuture {

      static <V> NeverScheduledFuture create() {
        return new NeverScheduledFuture<V>();
      }

      @Override public long getDelay(TimeUnit unit) {
        return Long.MAX_VALUE;
      }

      @Override public int compareTo(Delayed other) {
        return Longs.compare(getDelay(TimeUnit.NANOSECONDS), other.getDelay(TimeUnit.NANOSECONDS));
      }
    }
  }
}