java應用義務架構履行義務調劑示例

package com.yao;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 新的義務履行架構。
 * 在Java 5.0之前啟動一個義務是經由過程挪用Thread類的start()辦法來完成的，
 * 義務的提於交和履行是同時停止的，假如你想對義務的履行停止調劑，
 * 或是掌握同時履行的線程數目就須要額定編寫代碼來完成。
 * 5.0裡供給了一個新的義務履行架構使你可以輕松地調劑和掌握義務的履行，
 * 而且可以樹立一個相似數據庫銜接池的線程池來履行義務。
 * 這個架構重要有三個接口和其響應的詳細類構成。
 * 這三個接口是Executor, ExecutorService和ScheduledExecutorService。
 * （1）Executor接口：是用來履行Runnable義務的，它只界說一個辦法：
 * execute(Runnable command)：履行Ruannable類型的義務
 * （2）ExecutorService：繼續了Executor的辦法，並供給了履行Callable義務和中斷義務履行的辦事，
 * 其界說的辦法重要有：
 * submit(task)：可用來提交Callable或Runnable義務，並前往代表此義務的Future對象
 * invokeAll(collection of tasks)：批處置義務聚集，並前往一個代表這些義務的Future對象聚集
 * shutdown()：在完成已提交的義務後封閉辦事，不再接收新義務
 * shutdownNow()：停滯一切正在履行的義務並封閉辦事。
 * isTerminated()：測試能否一切義務都履行終了了。
 * isShutdown()：測試能否該ExecutorService已被封閉
 * （3）ScheduledExecutorService：繼續ExecutorService，供給了按時光支配履行義務的功效、
 * schedule(task, initDelay): 支配所提交的Callable或Runnable義務在initDelay指定的時光後履行。
 * scheduleAtFixedRate()：支配所提交的Runnable義務按指定的距離反復履行
 * scheduleWithFixedDelay()：支配所提交的Runnable義務在每次履行完後，期待delay所指定的時光後反復履行。
 *
 * 經由過程Executors類來取得各類辦事對象。
 * callable(Runnable task): 將Runnable的義務轉化成Callable的義務
 * newSingleThreadExecutor: 發生一個ExecutorService對象，這個對象只要一個線程可用來履行義務，若義務多於一個，義務將按前後次序履行。
 * newCachedThreadPool(): 發生一個ExecutorService對象，這個對象帶有一個線程池，線程池的年夜小會依據須要調劑，線程履行完義務後前往線程池，供履行下一次義務應用。
 * newFixedThreadPool(int poolSize)：發生一個ExecutorService對象，這個對象帶有一個年夜小為poolSize的線程池，若義務數目年夜於poolSize，義務會被放在一個queue裡次序履行。
 * newSingleThreadScheduledExecutor：發生一個ScheduledExecutorService對象，這個對象的線程池年夜小為1，若義務多於一個，義務將按前後次序履行。
 * newScheduledThreadPool(int poolSize): 發生一個ScheduledExecutorService對象，這個對象的線程池年夜小為poolSize，若義務數目年夜於poolSize，義務會在一個queue裡期待履行
 */
public class ExecuteArch {

 /**
  * 該線程輸入一行字符串
  */
 public static class MyThread implements Runnable {
  public void run() {
   System.out.println("Task repeating. " + System.currentTimeMillis());
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    System.out.println("Task interrupted. "
      + System.currentTimeMillis());
   }
  }
 }

 /**
  * 該Callable停止另外一個義務
  */
 public static class MyCallable implements Callable {
  private Future future;

  public MyCallable(Future future) {
   this.future = future;
  }

  public String call() {
   System.out.println("To cancell Task..."
     + +System.currentTimeMillis());
   this.future.cancel(true);
   return "Task cancelled!";
  }
 }

 /**
  * @param args
  * @throws ExecutionException
  * @throws InterruptedException
  */
 public static void main(String[] args) throws InterruptedException,
   ExecutionException {
  // 發生一個ExecutorService對象，這個對象帶有一個線程池，線程池的年夜小會依據須要調劑，
  // 線程履行完義務後前往線程池，供履行下一次義務應用。
  ExecutorService cachedService = Executors.newCachedThreadPool();
  Future myThreadFuture = cachedService.submit(new MyThread());
  Future myCallableFuture = cachedService.submit(new MyCallable(
    myThreadFuture));
  System.out.println(myCallableFuture.get());
  System.out.println("-----------------");

  // 將Runnable義務轉換成Callable義務
  Callable myThreadCallable = Executors.callable(new MyThread());
  Future myThreadCallableFuture = cachedService.submit(myThreadCallable);
  // 關於Runnable義務，轉換成Callable義務後，也沒有前往值
  System.out.println(myThreadCallableFuture.get());
  cachedService.shutdownNow();
  System.out.println("-----------------");

  // 發生一個ExecutorService對象，這個對象帶有一個年夜小為poolSize的線程池，
  // 若義務數目年夜於poolSize，義務會被放在一個queue裡次序履行
  ExecutorService fixedService = Executors.newFixedThreadPool(2);
  fixedService.submit(new MyThread());
  fixedService.submit(new MyThread());
  // 因為線程池年夜小為2，所今後面的義務必需期待後面的義務履行完後能力被履行。
  myThreadFuture = fixedService.submit(new MyThread());
  myCallableFuture = fixedService.submit(new MyCallable(myThreadFuture));
  System.out.println(myCallableFuture.get());
  fixedService.shutdownNow();
  System.out.println("-----------------");

  // 發生一個ScheduledExecutorService對象，這個對象的線程池年夜小為poolSize，
  // 若義務數目年夜於poolSize，義務會在一個queue裡期待履行
  ScheduledExecutorService fixedScheduledService = Executors
    .newScheduledThreadPool(2);
  // 新建義務1
  MyThread task1 = new MyThread();
  // 應用義務履行辦事立刻履行義務1，並且爾後每隔2秒履行一次義務1。
  myThreadFuture = fixedScheduledService.scheduleAtFixedRate(task1, 0, 2,
    TimeUnit.SECONDS);
  // 新建義務2
  MyCallable task2 = new MyCallable(myThreadFuture);
  // 應用義務履行辦事期待5秒後履行義務2，履行它後會將義務1封閉。
  myCallableFuture = fixedScheduledService.schedule(task2, 5,
    TimeUnit.SECONDS);
  System.out.println(myCallableFuture.get());
  fixedScheduledService.shutdownNow();
 }
}