java并发编程，通过Future取消任务

功能：通过Executor框架提供的线程池，提交任务，使用Future取消任务

任务：增长序列号，从0开始隔1s增长1

通过Future指定时间取消任务

IncrementSequence.java

 /**
  * 1s中增长1
  * @author Administrator
  *
  */
 public class IncrementSequence implements Runnable{
     public int sequence = 0;

     @Override
     public void run() {
         try {
             while(true){
                 sequence ++;
                 System.out.println("sequence = " + sequence);
                 //出现中断，抛出异常interruptexception，线程中断状态被清除
                 Thread.sleep(1000);
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

     }
 }

CancelTaskUsingFuture.java

 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;

 /**
  * 使用Future取消任务
  * @author Administrator
  *
  */
 public class CancelTaskUsingFuture {
     //线程池
     private static ExecutorService taskExec = Executors.newFixedThreadPool(1);

     /**
      * 指定执行任务时间，时间到通过future取消任务的执行
      * @param r
      * @param timeOut
      * @param unit
      */
     public static void timeRun(Runnable r, long timeOut, TimeUnit unit){
         Future<?> task = taskExec.submit(r);
         try {
             task.get(timeOut, unit);    //等待超时，等待给定的时间之后，获取其结果
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
             e.printStackTrace();
         } finally{
             task.cancel(true);
             //关闭线程池
             taskExec.shutdown();
         }

     }

     /**
      * 测试程序
      * @param args
      */
     public static void main(String args[]){
         Runnable scirpt = new IncrementSequence();

         //10s后结束任务
         timeRun(scirpt, 10, TimeUnit.SECONDS);
     }
 }