org.dbunit.util.concurrent.Executor Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of dbunit Show documentation

dbUnit is a JUnit extension (also usable from Ant and Maven) targeted for database-driven projects that, among other things, puts your database into a known state between test runs. This is an excellent way to avoid the myriad of problems that can occur when one test case corrupts the database and causes subsequent tests to fail or exacerbate the damage.

There is a newer version: 2.8.0

Show newest version

/*
  File: Executor.java

  Originally written by Doug Lea and released into the public domain.
  This may be used for any purposes whatsoever without acknowledgment.
  Thanks for the assistance and support of Sun Microsystems Labs,
  and everyone contributing, testing, and using this code.

  History:
  Date       Who                What
  19Jun1998  dl               Create public version
*/

package org.dbunit.util.concurrent;

/**
 * Interface for objects that execute Runnables,
 * as well as various objects that can be wrapped
 * as Runnables.
 * The main reason to use Executor throughout a program or
 * subsystem is to provide flexibility: You can easily
 * change from using thread-per-task to using pools or
 * queuing, without needing to change most of your code that
 * generates tasks.
 * 
 * The general intent is that execution be asynchronous,
 * or at least independent of the caller. For example,
 * one of the simplest implementations of execute
 * (as performed in ThreadedExecutor)
 * is new Thread(command).start();.
 * However, this interface allows implementations that instead
 * employ queueing or pooling, or perform additional
 * bookkeeping.
 * 

 * 
 * 
[ Introduction to this package. ]
 * 
 * @author Doug Lea
 * @author Last changed by: $Author$
 * @version $Revision$ $Date$
 * @since ? (pre 2.1)
 */
public interface Executor {
  /** 
   * Execute the given command. This method is guaranteed
   * only to arrange for execution, that may actually
   * occur sometime later; for example in a new
   * thread. However, in fully generic use, callers
   * should be prepared for execution to occur in
   * any fashion at all, including immediate direct
   * execution.
   * 

   * The method is defined not to throw 
   * any checked exceptions during execution of the command. Generally,
   * any problems encountered will be asynchronous and
   * so must be dealt with via callbacks or error handler
   * objects. If necessary, any context-dependent 
   * catastrophic errors encountered during
   * actions that arrange for execution could be accompanied
   * by throwing context-dependent unchecked exceptions.
   * 
   * However, the method does throw InterruptedException:
   * It will fail to arrange for execution
   * if the current thread is currently interrupted.
   * Further, the general contract of the method is to avoid,
   * suppress, or abort execution if interruption is detected
   * in any controllable context surrounding execution.
   **/
  public void execute(Runnable command) throws InterruptedException;

}