0.8、多线程学习——FutureTask

矫情吗；* 2021-11-05 02:52 514阅读 0赞

### 文章目录 ###

*   *   *  前言
         *  FutrueTask
         *   *  为 FutrueTask 增加自定义代码逻辑
             *   *  实现 Callable 接口并对象传入 FutureTask 构造函数
             *  FutureTask 的启动
             *   *  使用 Thread.start() 执行 FutureTask
                 *  使用线程池执行 FutureTask
                 *   *  线程池和 FutureTask 类
                     *  线程池和 Future 接口
         *  FutureTask.get()
         *   *  FutureTask.get() 用于获取线程执行结果
             *  FutureTask.get() 会阻塞当前线程
             *  FutureTask.get(n) 可以设置最大等待时间
         *  FutureTask.cancel(boolean)
         *   *  上代码
             *   *  执行结果
             *  如果我们注释掉中断futuer的一行
             *   *  执行结果

### 前言 ###

> 体能状态先于精神状态，习惯先于决心，聚焦先于喜好。

### FutrueTask ###

> 一般而言，我们总是强调可以通过 FutrueTask 来获得线程执行的结果，这是其区分 Thread和Runnable的一个亮点。但是其实FutureTask本身既不包含具体执行的代码，也无法触发线程的执行，其只是作为得到线程结果的一个“代表”，此外，它还有一个特性就是可以增加了线程的运行状态并且可以取消线程执行——虽然线程可能已经执行结束了导致取消未必成功。

#### 为 FutrueTask 增加自定义代码逻辑 ####

> FutureTask 并不包含具体的代码逻辑，具体的代码逻辑需要你继承 Callable 接口

##### 实现 Callable 接口并对象传入 FutureTask 构造函数 #####

> 我们需要实现 Callable 接口，并且重写其中的 call()方法，然后将重写的对象作为一个入参传入到 FutureTask 的构造函数，这样我们就得到了一个具有代码逻辑的 FutureTask 对象。  
> 代码如下：

#### FutureTask 的启动 ####

> 我们无法直接通过 FutureTask 来启动这个线程，因为FutureTask并没有提供 start()方法。  
> 我们可以借助于 Thread 类，或者线程池来执行 FutureTask 中Callable 中的run方法——在一个线程中执行。

##### 使用 Thread.start() 执行 FutureTask #####

> 将 FutureTask 对象作为入参传入Thread的构造函数，然后通过Thread.start()方法 运行FutureTask.  
> 显然这里运用了装饰器模式，最底层为 Callable对象,FutureTask 使其获得了获取执行结果的能力，Thread 使FutureTask 获得了执行的能力。  
> 看代码吧

//callable 是 future 的具体实现内容
     Callable callable=new Callable() { 
          @Override
          public Object call() throws Exception { 
              System.out.println(Thread.currentThread().getName());
              return true;
          }
      };
      
     //将 callable 传入到 FutureTask 构造函数
     FutureTask futureTask=new FutureTask(callable);
     //将futureTask 对象传入到 Thread 构造函数
     Thread t1=new Thread(futureTask);
     t1.setName("thread1");
     //运行线程
     t1.start();

##### 使用线程池执行 FutureTask #####

> 线程池执行线程任务直接提交就可以了，但是不同线程池在执行FutureTask 所展现的特性是不一样的，这个在下面的 FutureTask 的阻塞特性中进行介绍，这里只是提供一个线程池执行FutureTask的代码样例。

###### 线程池和 FutureTask 类 ######

> 在使用线程池执行FutureTask 时，我们有两种方式，第一种类似于 Thread中，先声明 Callable 对象，然后将之传入到 FutureTask 对象，然后直接提交给线程池，类似于下面

//callable 是 future 的具体实现内容
      Callable callable=new Callable() { 
           @Override
           public Object call() throws Exception { 
               System.out.println(Thread.currentThread().getName());
               return true;
           }
       };
       //将 callable 传入到 FutureTask 构造函数
       FutureTask futureTask=new FutureTask(callable);
    
       ExecutorService e=Executors.newFixedThreadPool(1);
       e.submit(futureTask);

###### 线程池和 Future 接口 ######

> 第二种是，我们可以借助于 Future 接口

### FutureTask.get() ###

> 对于 Futrue.get() 也是一样的

#### FutureTask.get() 用于获取线程执行结果 ####

> FutureTask.get() 用于获取线程执行结果，对于 Futrue.get() 也是一样的。  
> 其返回类型是在 Callable的call方法中决定的，当然你可以返回一个null

#### FutureTask.get() 会阻塞当前线程 ####

> 当调用 FutureTask.get() 或者 Futrue.get()时会阻塞当前线程。  
> 如果你使用了线程池，会展示不同的特性——某种情况下其会阻塞线程池。  
> 比如在线程池执行一个 FutureTask.get() ，对于 newFixedThreadPool，其至少会阻塞一个线程资源，对于 newCachedThreadPool，则会阻塞整个线程池，这个和线程池的阻塞队列有关，newCachedThreadPool的阻塞队列是 SynchronousQueue，其只有当下一个线程出现时才会释放当前线程，而 FutureTask.get() 阻塞了这个过程。

#### FutureTask.get(n) 可以设置最大等待时间 ####

> 这个不多说，设置最大等待时间。

//将 callable 传入到 FutureTask 构造函数
            FutureTask futureTask = new FutureTask(callable);
           
          	//···略
    
            //获取结果-这里注意时间
            List listResult = null;
            try { 
                listResult = (List) futureTask.get(2, TimeUnit.MINUTES);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            } catch (TimeoutException e) { 
                e.printStackTrace();
            }finally { 
            	//防止系统意外，取消 futureTask
                futureTask.cancel(true);
            }

### FutureTask.cancel(boolean) ###

> FutureTask 允许我们取消线程执行,而且,允许取消正在运行的线程——以抛出异常的方式中断  
> FutureTask 有很多个状态,我们可以查看它的状态

/**初始状态*/
     private static final int NEW          = 0;
     private static final int COMPLETING   = 1;
     private static final int NORMAL       = 2;
     private static final int EXCEPTIONAL  = 3;
     /**已取消-可能导致中断*/
     private static final int CANCELLED    = 4;
     /**中断中*/
     private static final int INTERRUPTING = 5;
     /**已中断*/
     private static final int INTERRUPTED  = 6;

#### 上代码 ####

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.FutureTask;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /** * Future 相关的测试 * @author jie.wu */
    public class FutureTest { 
    
    	
    	public static void main(String[] args) throws InterruptedException, ExecutionException { 
    		Callable c=new Callable<String>() { 
    			@Override
    			public String call() throws Exception { 
    				System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()+"开始:"+System.currentTimeMillis());
    				Thread.sleep(5*1000);
    				return "Over:"+System.currentTimeMillis();
    			}
    		
    		};
    		final FutureTask f=new FutureTask(c);
    		Thread t=new Thread(f);
    		t.setName("thread1");
    		t.start();
    		
    		//在另一个线程异步获取结果-避免阻塞当前线程
    		Thread thread2=new Thread("thread2") { 
    
    			@Override
    			public void run() { 
    				super.run();
    				try { 
    					System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()+"等待结果:"+f.get());
    				} catch (InterruptedException | ExecutionException e) { 
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    			
    		};
    		thread2.start();
    		
    		System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()+"线程状态-是否完成:"+f.isDone());
    		System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()+"线程状态-开始取消-可否执行:"+f.cancel(true));
    		System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()+"线程状态-是否已经在执行-不等于New:"+f.isDone());
    		System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()+"线程状态-是否取消:"+f.isCancelled());
    		
    	}
    	
    }

##### 执行结果 #####

1565695517794thread1开始:1565695517794
    1565695517794main线程状态-是否完成:false
    1565695517794main线程状态-开始取消-可否执行:true
    1565695517795main线程状态-是否已经在执行-不等于New:true
    1565695517795main线程状态-是否取消:true
    Exception in thread "thread2" java.util.concurrent.CancellationException
    	at java.util.concurrent.FutureTask.report(FutureTask.java:121)
    	at java.util.concurrent.FutureTask.get(FutureTask.java:192)
    	at del.FutureTest$2.run(FutureTest.java:41)

#### 如果我们注释掉中断futuer的一行 ####

//System.out.println(System.currentTimeMillis()+Thread.currentThread().getName()+"线程状态-开始取消-可否执行:"+f.cancel(true));

##### 执行结果 #####

1565695530740thread1开始:1565695530740
    1565695530741main线程状态-是否完成:false
    1565695530741main线程状态-是否已经在执行-不等于New:false
    1565695530741main线程状态-是否取消:false
    1565695530741thread2等待结果:Over:1565695535744