在默认的情况下，线程Thread对象不具有返回值的功能，如果在需要取得返回值的情况下是极不方便的，但在Java1.5的并发包中可以使用Future和Callable来使线程具有返回值的功能。
5.1 Callable与Runnable的主要区别
1.Callable接口的call(）方法可以有返回值，而Runnable接口的Run()方法没有返回值
2.Callable接口的call(）方法可以声明抛出异常，而Runnable接口的run()方法不可以声明抛出异常。
执行完Callable接口中的任务后，返回值是通过Future接口进行获得的。
5.2 方法get()结合ExecutorService中的submit(Callable的使用)
package cn.yu.callable;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
private int age;
public MyCallable(int age) {
super();
this.age = age;
}
@Override
public String call() throws Exception {
Thread.sleep(8000);
return "返回值 age="+age;
}
}
--------------------------------
package cn.yu.callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test {
public static void main(String[] args) throws InterruptedException, ExecutionException {
MyCallable callable = new MyCallable(100);
ThreadPoolExecutor executor = new ThreadPoolExecutor(2,3,5L,TimeUnit.SECONDS,new LinkedBlockingDeque());
Future<String> future = executor.submit(callable);
System.out.println("开始"+System.currentTimeMillis());
System.out.println(future.get());
System.out.println("结束"+System.currentTimeMillis());
}
}
运行结果：
开始1556202550917
返回值 age=100
结束1556202558918
从控制台输出结果看，方法get()具有阻塞特性。
5.3 方法get()结合ExecutorService中的submit(Runnable)和isDone()的使用
package cn.yu.callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test2 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("我是Runnable接口");
}
};
ExecutorService service = Executors.newCachedThreadPool();
Future future = service.submit(runnable);
System.out.println("get方法返回值："+future.get()+",isDone的返回值："+future.isDone());
}
}
输出结果：
我是Runnable接口
get方法返回值：null,isDone的返回值：true
通过实验可知，如果submit()方法传入Callable接口则可以有返回值，如果传入Runnable则无返回值，打印的结果就是null.方法get（）具有阻塞特性，而isDone(）方法无阻塞特性。
5.4 使用ExecutorService接口中的方法submit(Runnable,T result)
方法submit(Runnable,T result)的第二个参数result可以作为执行结果的返回值，而不要使用get()方法来进行获得。
package cn.yu.callable;
public class Userinfo {
private String username;
private String password;
public Userinfo() {
super();
}
public Userinfo(String username,String password) {
super();
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
-----------------
package cn.yu.callable;
public class MyRunnable implements Runnable {
private Userinfo userinfo;
public MyRunnable(Userinfo userinfo) {
super();
this.userinfo = userinfo;
}
@Override
public void run() {
userinfo.setUsername("username");
userinfo.setPassword("password");
}
}
---------------------------
package cn.yu.callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test3 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Userinfo userinfo = new Userinfo();
MyRunnable myrunnable = new MyRunnable(userinfo);
ThreadPoolExecutor pool = new ThreadPoolExecutor(10,10,10,TimeUnit.SECONDS,new LinkedBlockingDeque<Runnable>());
Future<Userinfo> future = pool.submit(myrunnable,userinfo);
System.out.println("begin time="+System.currentTimeMillis());
userinfo = future.get();
System.out.println("返回值"+userinfo.getUsername()+"-"+userinfo.getPassword());
System.out.println("end time"+System.currentTimeMillis());
}
}
运行结果：
begin time=1556204320917
返回值username-password
end time1556204320917
5.5 方法cancel(boolean mayInterruptIfRunning )和isCancelled()的使用
方法Cancel(boolean mayInterruptIfRunning)的参数mayInterruptIfRunning的作用是：如果线程正在运行则是否中断正在运行的线程，在代码中需要使用if(Thread.currentThread().isInterrupted())进行配合
方法cancel()的返回值代表发送取消任务的命令是否成功完成。
如果线程任务已经运行完毕，线程对象已经销毁，则方法cancel(）的返回值是false,代表发送取消的命令并没有成功。
5.5 方法get(long timeout,TimeUnit unit)
方法get(long timeout,TimeUnit unit)的作用是在指定的最大时间内等待获得返回值。
5.6 异常的处理
接口Callable任务在执行时有可能会出现异常，那在Callable中异常是如何处理的呢？
5.7 自定义拒绝策略RejectedExecutionHandler
接口RejectedExecutionHandler的主要作用是当前线程池关闭后依然有任务要执行时，可以实现一些处理。
package cn.yu.callable.executionhandler;
public class MyRunnable implements Runnable{
private String username;
public MyRunnable(String name) {
super();
this.username = name;
}
public void run() {
System.out.println(username+"在运行！");
}
}
--------------------------
package cn.yu.callable.executionhandler;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
public class MyRejectedExecutionHandler implements RejectedExecutionHandler{
public void rejectedExecution(Runnable r,ThreadPoolExecutor executor) {
System.out.println(((FutureTask)r).toString()+"被拒绝");
}
}
---------------------------------
package cn.yu.callable.executionhandler;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
public class Test {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
ThreadPoolExecutor executor = (ThreadPoolExecutor) service;
executor.setRejectedExecutionHandler(new MyRejectedExecutionHandler());
executor.submit(new MyRunnable("A"));
executor.submit(new MyRunnable("B"));
executor.submit(new MyRunnable("C"));
executor.shutdown();
executor.submit(new MyRunnable("D"));
}
}
运行结果：
A在运行！
B在运行！
C在运行！
java.util.concurrent.FutureTask@4783da3f[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@2dda6444[Wrapped task = cn.yu.callable.executionhandler.MyRunnable@5e9f23b4]]被拒绝
5.8 方法execute()与submit()的区别
1.方法execute()没有返回值，而submit()方法可以有返回值。
2.方法execute()在默认的情况下异常直接抛出，不能捕获，但可以通过自定义Thread-Factory的方式进行捕获，而submit()方法在默认的情况，可以catch Execution-Exception捕获异常。
execute()方法也可以捕获异常的例子：
package cn.yu.callable;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test4 {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(50,Integer.MAX_VALUE,5,TimeUnit.SECONDS,
new LinkedBlockingDeque<Runnable>());
executor.setThreadFactory(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r) ;
t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("execute()方法通过使用自定义");
System.out.println("ThreadFactory也能捕获异常了");
e.printStackTrace();
}
});
return t;
}
});
executor.execute(new Runnable() {
@Override
public void run() {
Integer.parseInt("a");
}
});
}
}
运行结果：
execute()方法通过使用自定义
ThreadFactory也能捕获异常了
java.lang.NumberFormatException: For input string: "a"
at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:68)
at java.base/java.lang.Integer.parseInt(Integer.java:658)
at java.base/java.lang.Integer.parseInt(Integer.java:776)
at Test/cn.yu.callable.Test4$2.run(Test4.java:36)
at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
at java.base/java.lang.Thread.run(Thread.java:835)
5.9 验证Future的缺点
接口Future的实现类是FutureTask.java,而且在使用线程池时，默认的情况下也是使用FutureTask.java类作为接口Future的实现类，也就是说，如果在使用Future与Callable的情况下，使用Future接口也就是在使用FutureTask.java类
Callable接口与Runnable接口在对比时主要的优点是，Callable接口与Runnable接口在对比时主要的优点是，Callable接口可以通过Future取得返回值。但要注意的是，Future接口调用get()方法取得处理的结果值时是阻塞性的，也就是如果调用Future对象的get()方法时，任务尚未执行完成，则调用get()方法时一直阻塞到此任务完成时为止。如果是这样的效果，则前面先执行的任务一旦耗时很多，则后面的任务调用get()方法就呈阻塞状态，也就是排队进行等待，大大影响运行效率。也就是主线程并不能保证首先获得的是最先完成任务的返回值，这就是Future的缺点，影响效率。
5862
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
