java线程——详解Callable、Future和FutureTask

回顾：


接上篇博客

java线程——三种创建线程的方式 ，这篇博客主要介绍第三种方式Callable和Future。比较继承Thread类和实现Runnable接口，接口更加灵活，使用更广泛。但这两种方式都没有返回值，要想返回相应的数据，就要使用Callable和Future方式。


基础：

1、Callable

还是从定义开始，Callable接口有返回值，并且可以抛出异常。

  1. /**（有返回值的任务，可能抛出异常）
  2.  * A task that returns a result and may throw an exception.
  3.  * Implementors define a single method with no arguments called
  4.  * {@code call}.
  5.  
  6.  * @see Executor
  7.  * @since 1.5
  8.  * @author Doug Lea
  9.  * @param <V> the result type of method {@code call}
  10.  */
  11. @FunctionalInterface
  12. public interface Callable<V> {
  13.    
  14.     V call() throws Exception;
  15. }

2、Future

Future同样也是一个接口，主要方法如下，方法的功能比较容易理解，所以就没有写注释。主要作用：获取任务执行结果，中断任务等。

  1. package java.util.concurrent;
  2.  
  3. public interface Future<V> {
  4.  
  5.    
  6.     boolean cancel(boolean mayInterruptIfRunning);
  7.  
  8.    
  9.     boolean isCancelled();
  10.  
  11.    
  12.     boolean isDone();
  13.  
  14.     
  15.     V get() throws InterruptedException, ExecutionException;
  16.  
  17.    
  18.     V get(long timeout, TimeUnit unit)
  19.         throws InterruptedException, ExecutionException, TimeoutException;
  20. }

3、FutureTask 

  1. public class FutureTask<V> implements RunnableFuture<V> {
  2. ......
  3. }
  4.  
  5. public interface RunnableFuture<V> extends Runnable, Future<V> {
  6. ......
  7. }


       FutureTask实现了RunnableFuture接口，而RunnableFuture接口继承了Runnable和Future。也就是说，它既可以作为Runnable被线程执行，也可以作为Future得到Callable返回值。


使用：

方法一：Callable+Future

  1. public class CallableAndFuture {
  2. 	/**
  3. 	 * 实现Callable接口
  4. 	 * 
  5. 	 * @author YANG
  6. 	 *
  7. 	 */
  8. 	public static class MyCallable implements Callable {
  9.  
  10. 		private int flag = 0;
  11.  
  12. 		public MyCallable(int flag) {
  13.  
  14. 			this.flag = flag;
  15.  
  16. 		}
  17.  
  18. 		// 重写call方法
  19. 		public String call() throws Exception {
  20. 			// 情况一：flag=0 返回0
  21. 			if (this.flag == 0) {
  22.  
  23. 				return "flag = 0";
  24.  
  25. 			}
  26. 			// 情况二：flag=1 返回looping 陷入死循环
  27. 			if (this.flag == 1) {
  28.  
  29. 				try {
  30.  
  31. 					while (true) {
  32.  
  33. 						System.out.println("looping.");
  34.  
  35. 						Thread.sleep(2000);
  36.  
  37. 					}
  38. 					// 情况三：出现异常
  39. 				} catch (InterruptedException e) {
  40.  
  41. 					System.out.println("Interrupted");
  42.  
  43. 				}
  44.  
  45. 				return "false";
  46.  
  47. 			} else {
  48.  
  49. 				throw new Exception("Bad flag value!");
  50.  
  51. 			}
  52.  
  53. 		}
  54.  
  55. 	}
  56.  
  57. 	public static void main(String[] args) {
  58.  
  59. 		// 定义3个Callable类型的任务，构造方法中制定flag的值
  60. 		MyCallable task1 = new MyCallable(0);
  61.  
  62. 		MyCallable task2 = new MyCallable(1);
  63.  
  64. 		MyCallable task3 = new MyCallable(2);
  65.  
  66. 		// 创建一个执行任务的服务
  67.  
  68. 		ExecutorService es = Executors.newFixedThreadPool(3);
  69.  
  70. 		try {
  71.  
  72. 			// 提交并执行任务，任务启动时返回了一个Future对象，
  73.  
  74. 			// 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
  75.  
  76. 			Future future1 = null;
  77.  
  78. 			future1 = es.submit(task1);
  79.  
  80. 			// 获得第一个任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行
  81.  
  82. 			System.out.println("task1: " + future1.get());
  83.  
  84. 			Future future2 = es.submit(task2);
  85.  
  86. 			// 等待5秒后，再停止第二个任务。因为第二个任务进行的是无限循环
  87.  
  88. 			Thread.sleep(5000);
  89.  
  90. 			System.out.println("task2 cancel: " + future2.cancel(true));
  91.  
  92. 			// 测试抛出异常
  93.  
  94. 			Future future3 = es.submit(task3);
  95.  
  96. 			System.out.println("task3: " + future3.get());
  97.  
  98. 		} catch (Exception e) {
  99.  
  100. 			System.out.println(e.toString());
  101.  
  102. 		}
  103.  
  104. 		// 停止任务执行服务
  105.  
  106. 		es.shutdownNow();
  107.  
  108. 	}
  109. }


执行结果：




方法二：Callable+FutureTask

      分析两种方法不同之处就在于Future和FutureTask，其中一个是接口，一个是类。因此，只有main方法调用部分不同，上面的MyCallable类中的内容保持不变。

  1. public static void main(String[] args) {
  2.  
  3. 		MyCallable task1 = new MyCallable(0);
  4. 		FutureTask ft1 = new FutureTask(task1);
  5. 		MyCallable task2 = new MyCallable(1);
  6. 		FutureTask ft2 = new FutureTask(task2);
  7. 		MyCallable task3 = new MyCallable(2);
  8. 		FutureTask ft3 = new FutureTask(task3);		
  9.  
  10. 		try {
  11. 		//启动task1
  12. 			new Thread(ft1, "子线程").start();
  13. 			System.out.println(ft1.get());
  14. 			
  15.  
  16. 			//等待5秒后，停止task2
  17. 			new Thread(ft2, "子线程").start();
  18. 			Thread.sleep(5000);
  19. 			System.out.println("task2 cancel:" + ft2.cancel(true));
  20. 			
  21. 			//启动task3
  22. 			new Thread(ft3, "子线程").start();
  23. 			System.out.println("task3:" + ft3.get());
  24. 		} catch (InterruptedException | ExecutionException e) {
  25.  
  26. 			System.out.println(e.toString());
  27. 		}
  28.  
  29. 	}

       

       其执行结果与方法一完全相同，对比这两种方式，第二种比较容易读懂，第一种相对困难些。下篇博客我们介绍Executor、ExecutorService等内容，相信之后理解起来就会很轻松了。

posted @ 2018-07-18 16:29  星朝  阅读(618)  评论(0)  编辑  收藏  举报