Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 java.util.List;
Factory methods for ExecutorService for testing.

Author(s):
Chris Nokleberg
Since:
14.0
 
 public final class TestingExecutors {
   private TestingExecutors() {}

  
Returns a ScheduledExecutorService that never executes anything.

The shutdownNow method of the returned executor always returns an empty list despite the fact that everything is still technically awaiting execution. The getDelay method of any java.util.concurrent.ScheduledFuture returned by the executor will always return the max long value instead of the time until the user-specified delay.

 
     return new NoOpScheduledExecutorService();
   }

  
Creates a scheduled executor service that runs each task in the thread that invokes execute/submit/schedule, as in CallerRunsPolicy. This applies both to individually submitted tasks and to collections of tasks submitted via invokeAll, invokeAny, schedule, scheduleAtFixedRate, and scheduleWithFixedDelay. In the case of tasks submitted by invokeAll or invokeAny, tasks will run serially on the calling thread. Tasks are run to completion before a Future is returned to the caller (unless the executor has been shutdown).

The returned executor is backed by the executor returned by com.google.common.util.concurrent.MoreExecutors.sameThreadExecutor() and subject to the same constraints.

Although all tasks are immediately executed in the thread that submitted the task, this ExecutorService imposes a small locking overhead on each task submission in order to implement shutdown and termination behavior.

Because of the nature of single-thread execution, the methods scheduleAtFixedRate and scheduleWithFixedDelay are not supported by this class and will throw an UnsupportedOperationException.

The implementation deviates from the ExecutorService specification with regards to the 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 invokeAll or invokeAny which are pending serial execution, even the subset of the tasks that have not yet started execution. It is unclear from the ExecutorService specification if these should be included, and it's much easier to implement the interpretation that they not be. Finally, a call to shutdown or shutdownNow may result in concurrent calls to invokeAll/invokeAny throwing RejectedExecutionException, although a subset of the tasks may already have been executed.

Since:
15.0
 
     return new SameThreadScheduledExecutorService();
  }
  private static final class NoOpScheduledExecutorService
    private volatile boolean shutdown;
    @Override public void shutdown() {
       = true;
    }
    @Override public List<RunnableshutdownNow() {
      shutdown();
      return ImmutableList.of();
    }
    @Override public boolean isShutdown() {
      return ;
    }
    @Override public boolean isTerminated() {
      return ;
    }
    @Override public boolean awaitTermination(long timeoutTimeUnit unit) {
      return true;
    }
    @Override public void execute(Runnable runnable) {}
    @Override public <V> ListenableScheduledFuture<V> schedule(
        Callable<V> callablelong delayTimeUnit unit) {
      return NeverScheduledFuture.create();
    }
        Runnable commandlong delayTimeUnit unit) {
      return NeverScheduledFuture.create();
    }
        Runnable commandlong initialDelaylong periodTimeUnit unit) {
      return NeverScheduledFuture.create();
    }
        Runnable commandlong initialDelaylong delayTimeUnit unit) {
      return NeverScheduledFuture.create();
    }
    private static class NeverScheduledFuture<V>
        extends AbstractFuture<V> implements ListenableScheduledFuture<V> {
      static <V> NeverScheduledFuture<V> create() {
        return new NeverScheduledFuture<V>();
      }
      @Override public long getDelay(TimeUnit unit) {
        return .;
      }
      @Override public int compareTo(Delayed other) {
        return Longs.compare(getDelay(.), other.getDelay(.));
      }
    }
  }
New to GrepCode? Check out our FAQ X