logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Future和Callable的使用总结

 创始元灵6666 2022-06-17 发布于河北

在默认的情况下，线程Thread对象不具有返回值的功能，如果在需要取得返回值的情况下是极为不方便的，但在Java1.5的并发包中可以使用Future和Callable来使线程具有返回值的功能。

1.Future和Callable的介绍

接口Callable与线程功能密不可分，但和Runnable的主要区别为:

(1) 接口Callable的call()方法可以有返回值，但Runnable接口的run()方法没有返回值。

(2) Callable接口的call()方法可以声明抛出异常，而Runnable接口的run()方法不可以声明抛出异常。

执行完Callable接口中的任务后，返回值是通过Future接口进行获得的。

2.方法get()结合ExecutorService中的submit(Callable<T>)的使用

方法submit(Callable<T>)可以执行参数为Callable的任务，方法get()用于获得返回值，示例如下：

  1. package mycallable;
  3. import java.util.concurrent.Callable;
  5. public class MyCallable implements Callable<String> {
  7. 	private int age;
  9. 	public MyCallable(int age) {
  10. 		super();
  11. 		this.age = age;
  12. 	}
  14. 	public String call() throws Exception {
  15. 		Thread.sleep(8000);
  16. 		return "返回值 年龄是：" + age;
  17. 	}
  19. }
  1. package test.run;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.Future;
  5. import java.util.concurrent.LinkedBlockingDeque;
  6. import java.util.concurrent.ThreadPoolExecutor;
  7. import java.util.concurrent.TimeUnit;
  9. import mycallable.MyCallable;
  11. public class Run {
  13. 	public static void main(String[] args) throws InterruptedException {
  14. 		try {
  15. 			MyCallable callable = new MyCallable(100);
  17. 			ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3, 5L,
  18. 					TimeUnit.SECONDS, new LinkedBlockingDeque());
  19. 			Future<String> future = executor.submit(callable);
  20. 			System.out.println("main A " + System.currentTimeMillis());
  21. 			System.out.println(future.get());
  22. 			System.out.println("main B " + System.currentTimeMillis());
  23. 		} catch (ExecutionException e) {
  24. 			e.printStackTrace();
  25. 		}
  26. 	}
  27. }

3.方法get()结合ExecutorService中的submit(Runnable)和isDone()的使用

方法submit()不仅可以传入Callable对象，也可以传入Runnable对象，说明submit方法支持有返回值和无返回值的功能。如果submit方法传入Callable接口则可以有返回值，如果传入Runnable则无返回值，打印的结果就是null。方法get()具有阻塞特性，而isDone()方法无阻塞特性。

  1. package test.run;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.Future;
  8. /**
  9.  * 如果submit方法传入Callable接口则可以有返回值，如果传入Runnable则无返回值，打印的结果就是null。方法get()具有阻塞特性，而isDone()方法无阻塞特性
  10.  * @author linhaiy
  11.  * @date 2019.03.06
  12.  */
  13. public class Run {
  15. 	public static void main(String[] args) {
  16. 		try {
  17. 			Runnable runnable = new Runnable() {
  18. 				@Override
  19. 				public void run() {
  20. 					System.out.println("打印的信息");
  21. 				}
  22. 			};
  23. 			ExecutorService executorRef = Executors.newCachedThreadPool();
  24. 			Future future = executorRef.submit(runnable);
  25. 			System.out.println(future.get() + " " + future.isDone());
  26. 		} catch (InterruptedException e) {
  27. 			e.printStackTrace();
  28. 		} catch (ExecutionException e) {
  29. 			e.printStackTrace();
  30. 		}
  31. 	}
  32. }

4.使用ExecutorService接口中的方法submit(Runnable,T result)

方法submit(Runnable,T result)的第2个参数result可以作为执行结果的返回值，而不需要使用get()方法来进行获得。

  1. package entity;
  3. public class Userinfo {
  5. 	private String username;
  6. 	private String password;
  8. 	public Userinfo() {
  9. 		super();
  10. 	}
  12. 	public Userinfo(String username, String password) {
  13. 		super();
  14. 		this.username = username;
  15. 		this.password = password;
  16. 	}
  18. 	public String getUsername() {
  19. 		return username;
  20. 	}
  22. 	public void setUsername(String username) {
  23. 		this.username = username;
  24. 	}
  26. 	public String getPassword() {
  27. 		return password;
  28. 	}
  30. 	public void setPassword(String password) {
  31. 		this.password = password;
  32. 	}
  34. }
  1. package myrunnable;
  3. import entity.Userinfo;
  5. public class MyRunnable implements Runnable {
  7. 	private Userinfo userinfo;
  9. 	public MyRunnable(Userinfo userinfo) {
  10. 		super();
  11. 		this.userinfo = userinfo;
  12. 	}
  14. 	@Override
  15. 	public void run() {
  16. 		userinfo.setUsername("usernameValue");
  17. 		userinfo.setPassword("passwordValue");
  18. 	}
  19. }
  1. package test;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.Future;
  5. import java.util.concurrent.FutureTask;
  6. import java.util.concurrent.LinkedBlockingDeque;
  7. import java.util.concurrent.ThreadPoolExecutor;
  8. import java.util.concurrent.TimeUnit;
  10. import myrunnable.MyRunnable;
  11. import entity.Userinfo;
  13. public class Test {
  15. 	FutureTask abc;   //接口Future的实现类
  17. 	public static void main(String[] args) {
  18. 		try {
  19. 			Userinfo userinfo = new Userinfo();
  20. 			MyRunnable myrunnable = new MyRunnable(userinfo);
  22. 			ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 10, 10,
  23. 					TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
  24. 			Future<Userinfo> future = pool.submit(myrunnable, userinfo);
  25. 			System.out.println(future);
  26. 			System.out.println("begin time=" + System.currentTimeMillis());
  27. 			userinfo = future.get();
  28. 			System.out.println("get value " + userinfo.getUsername() + " "
  29. 					+ userinfo.getPassword());
  30. 			System.out.println("  end time=" + System.currentTimeMillis());
  31. 		} catch (InterruptedException e) {
  32. 			e.printStackTrace();
  33. 		} catch (ExecutionException e) {
  34. 			e.printStackTrace();
  35. 		}
  36. 	}
  37. }

5.方法cancel(boolean mayInterruptIfRunning) 和isCancelled()的使用

方法cancel(boolean mayInterruptIfRunning)的参数mayInterruptIfRunning的作用是：如果线程正在运行则是否中断正在运行的线程，在代码中需要使用if(Thread.currentThread().isInterrupted())进行配合。

方法cancel()的返回值代表发送取消任务的命令是否成功完成。

6.方法get(long timeout,TimeUnit unit)的使用

方法get(long timeout,TimeUnit unit)的作用是在指定的最大时间内等待获得返回值。

  1. package mycallable;
  3. import java.util.concurrent.Callable;
  5. public class MyCallable implements Callable<String> {
  6. 	public String call() throws Exception {     
  7. 		Thread.sleep(10000);                    //目的是为了在指定时间内获取不到返回值
  8. 		System.out.println("sleep 10秒执行完了！");
  9. 		return "anyString";
  10. 	}
  11. }
  1. package test.run;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.Future;
  5. import java.util.concurrent.LinkedBlockingDeque;
  6. import java.util.concurrent.ThreadPoolExecutor;
  7. import java.util.concurrent.TimeUnit;
  8. import java.util.concurrent.TimeoutException;
  10. import mycallable.MyCallable;
  12. public class Run {
  14. 	public static void main(String[] args) {
  15. 		try {
  16. 			MyCallable callable = new MyCallable();
  17. 			ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3, 5L,
  18. 					TimeUnit.SECONDS, new LinkedBlockingDeque());
  19. 			System.out.println("begin " + System.currentTimeMillis());
  20. 			Future<String> future = executor.submit(callable);
  21. 			System.out.println("返回值" + future.get(5, TimeUnit.SECONDS));
  22. 			System.out.println("  end " + System.currentTimeMillis());
  23. 		} catch (InterruptedException e) {
  24. 			System.out.println("进入catch InterruptedException");
  25. 			e.printStackTrace();
  26. 		} catch (ExecutionException e) {
  27. 			System.out.println("进入catch ExecutionException");
  28. 			e.printStackTrace();
  29. 		} catch (TimeoutException e) {
  30. 			System.out.println("进入catch TimeoutException");
  31. 			e.printStackTrace();
  32. 		}
  33. 	}
  34. }

7.自定义拒绝策略RejectedExecutionHandler接口的使用

接口RejectedExecutionHandler的主要作用是当线程池关闭后依然有任务要执行时，可以实现一些处理。

  1. package com.executionhandler;
  3. import java.util.concurrent.FutureTask;
  4. import java.util.concurrent.RejectedExecutionHandler;
  5. import java.util.concurrent.ThreadPoolExecutor;
  7. public class MyRejectedExecutionHandler implements RejectedExecutionHandler {
  8. 	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
  9. 		System.out.println(((FutureTask) r).toString() + " 被拒绝!");
  10. 	}
  11. }
  1. package com.executionhandler;
  3. public class MyRunnable implements Runnable {
  5. 	private String username;
  7. 	public MyRunnable(String username) {
  8. 		super();
  9. 		this.username = username;
  10. 	}
  12. 	public void run() {
  13. 		System.out.println(username + " 在运行！");
  14. 	}
  15. }
  1. package com.executionhandler;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  5. import java.util.concurrent.ThreadPoolExecutor;
  7. public class Run {
  9. 	public static void main(String[] args) {
  11. 		ExecutorService service = Executors.newCachedThreadPool();
  12. 		ThreadPoolExecutor executor = (ThreadPoolExecutor) service;
  13. 		executor.setRejectedExecutionHandler(new MyRejectedExecutionHandler());
  14. 		service.submit(new MyRunnable("A"));
  15. 		service.submit(new MyRunnable("B"));
  16. 		service.submit(new MyRunnable("C"));
  17. 		executor.shutdown();
  18. 		service.submit(new MyRunnable("D"));
  20. 	}
  21. }

8.方法execute()与submit()的区别

(1) 方法execute()没有返回值，而submit()方法可以有返回值。

(2) 方法execute()在默认的情况下异常直接抛出，不能捕获，但可以通过自定义ThreadFactory的方式进行捕获，而submit()方法在默认的情况下，可以catch Execution-Exeception捕获异常

9.验证Future的缺点

  1. package mycallable;
  3. import java.util.concurrent.Callable;
  5. public class MyCallable implements Callable<String> {
  7. 	private String username;
  8. 	private long sleepValue;
  10. 	public MyCallable(String username, long sleepValue) {
  11. 		super();
  12. 		this.username = username;
  13. 		this.sleepValue = sleepValue;
  14. 	}
  16. 	@Override
  17. 	public String call() throws Exception {
  18. 		System.out.println(username);
  19. 		Thread.sleep(sleepValue);
  20. 		return "return " + username;
  21. 	}
  22. }
  1. package test;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.Callable;
  6. import java.util.concurrent.ExecutionException;
  7. import java.util.concurrent.Future;
  8. import java.util.concurrent.LinkedBlockingDeque;
  9. import java.util.concurrent.ThreadPoolExecutor;
  10. import java.util.concurrent.TimeUnit;
  12. import mycallable.MyCallable;
  14. public class Test {
  16. 	public static void main(String[] args) {
  17. 		try {
  18. 			MyCallable callable1 = new MyCallable("username1", 5000);
  19. 			MyCallable callable2 = new MyCallable("username2", 4000);
  20. 			MyCallable callable3 = new MyCallable("username3", 3000);
  21. 			MyCallable callable4 = new MyCallable("username4", 2000);
  22. 			MyCallable callable5 = new MyCallable("username5", 1000);
  24. 			List<Callable> callableList = new ArrayList<Callable>();
  25. 			callableList.add(callable1);
  26. 			callableList.add(callable2);
  27. 			callableList.add(callable3);
  28. 			callableList.add(callable4);
  29. 			callableList.add(callable5);
  31. 			List<Future> futureList = new ArrayList<Future>();
  33. 			ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
  34. 					new LinkedBlockingDeque<Runnable>());
  35. 			for (int i = 0; i < 5; i++) {
  36. 				futureList.add(executor.submit(callableList.get(i)));
  37. 			}
  38. 			System.out.println("run first time=  " + System.currentTimeMillis());
  39. 			for (int i = 0; i < 5; i++) {
  40. 				System.out.println(futureList.get(i).get() + " " + System.currentTimeMillis());
  41. 			}
  42. 			// 按顺序打印的效果
  43. 			// 说明一个Future对应指定的一个Callable
  44. 		} catch (InterruptedException e) {
  45. 			e.printStackTrace();
  46. 		} catch (ExecutionException e) {
  47. 			e.printStackTrace();
  48. 		}
  49. 	}
  50. }

总结：Future和Callable这两个接口的优点就是从线程中返回数据以便进行后期的处理，但是FutureTask类也有其自身的缺点，就是阻塞性。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 创始元灵6666 > 《work》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多