Excutor

1. .Excutor 这个只是一个简单的接口 执行程序的意思

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

生成者和消费者的模式，很好的将任务分开来执行，各不影响。 下面的源码中写的东西。
An object that executes submitted {@link Runnable} tasks. This interface provides a way of decoupling（这个是一个解耦的过程，将执行的细节分开了） task submission from the mechanics of how each task will be run, including details of thread use, scheduling, etc. An {@code Executor} is normally used instead of explicitly creating threads. For example, rather than invoking {@code new Thread(new(RunnableTask())).start()} for each of a set of tasks, you might use:

 Executor executor = anExecutor;
 executor.execute(new RunnableTask1());
 executor.execute(new RunnableTask2());

However, the {@code Executor} interface does not strictly require that execution be asynchronous. In the simplest case, an executor can run the submitted task immediately in the caller’s thread: 并不是严格的要求使用异步的执行，也是可以是直接使用调用着提供的线程。其实有时候，我们可以把直接写线程的东西，用Executor封装起来，如果每个事务启动的时候都需要创建一个线程，我们直接修改Executor的实现就好了。面向接口编程，不用修改其他的代码。非常的棒。假如下次我们执行的时候不在需要每次都生产一个线程那个时候，我们修改代码很方便啊。很好的扩展我们的需求。

class DirectExecutor implements Executor {
    public void execute(Runnable r) {
     r.run();
   }
 }}

就如我刚才说的，每次调用的时候都去产生新的线程，这样我们也是可以实现的。

class ThreadPerTaskExecutor implements Executor {
   public void execute(Runnable r) {
      new Thread(r).start();
    }
  }}

Many {@code Executor} implementations impose some sort of limitation on how and when tasks are scheduled.(有时候对于执行任务有一定的周期的限制，一个接一个的) The executor below serializes the submission of tasks to a second executor, illustrating a composite executor. 这个下面的是源码中的例子，其实我们真正的实现线程池之内的东西，都是按照这种那样的限制进行执行的。生产和消费分开来真的是一个非常不错的东西。其实在我们的平时写代码的时候，解耦。很多的用到了我们的设计模式里面的知识。我自己也是越来越爱上了这个东西。重新买了一本英文的head first pattern 来看看起来太有味道的感觉了。

class SerialExecutor implements Executor {
 *   final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
 *   final Executor executor;
 *   Runnable active;
 *
 *   SerialExecutor(Executor executor) {
 *     this.executor = executor;
 *   }
 *
 *   public synchronized void execute(final Runnable r) {
 *     tasks.offer(new Runnable() {
 *       public void run() {
 *         try {
 *           r.run();
 *         } finally {
 *           scheduleNext();
 *         }
 *       }
 *     });
 *     if (active == null) {
 *       scheduleNext();
 *     }
 *   }
 *
 *   protected synchronized void scheduleNext() {
 *     if ((active = tasks.poll()) != null) {
 *       executor.execute(active);
 *     }
 *   }
 * }}

1. （Executor）将为你管理Thread对象，从而简化了并发编程。
   Executor在客户端和执行任务之间提供了一个间接层，Executor代替客户端执行任务。Executor允许你管理异步任务的执行，而无须显式地管理线程的生命周期。Executor在Java SE5/6中时启动任务的优选方法。Executor引入了一些功能类来管理和使用线程Thread，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等
   

Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

接口Executor只有一个方法execute，接口ExecutorService扩展了Executor并添加了一些生命周期管理的方法，如shutdown、submit等。一个Executor的生命周期有三种状态，运行 ，关闭 ，终止。shutdown() 启动一个关闭命令，不再接受新任务，当所有已提交任务执行完后，就关闭。
3. Callable，Future用于返回结果
Future< V>代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞。FutureTask< V>实现了Future< V>和Runable< V>。Callable代表一个有返回值得操作。

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

 The {@link FutureTask} class is an implementation of {@code Future} that
 * implements {@code Runnable}, and so may be executed by an {@code Executor}.
 * For example, the above construction with {@code submit} could be replaced by:
 *  <pre> {@code
 * FutureTask<String> future =
 *   new FutureTask<String>(new Callable<String>() {
 *     public String call() {
 *       return searcher.search(target);
 *   }});
 * executor.execute(future);}
 *

1. 执行的策略
   
   
   
   
   

这些写的都是非常经典的文章，值得好好的品味，编程是一种艺术的生活。得好好的体会和品味。
简单粗暴的关闭和慢慢的等待执行完任务..给我们解释的非常的清楚，有时候多看看前辈的经验还是十分的有效的一种方式。

最后

以上就是高挑玉米为你收集整理的Excutor的全部内容，希望文章能够帮你解决Excutor所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。