Callable和Future的学习
Callable和Future的学习
一、Callable
Callable接口比起Runnable接口的优点就是可以获取线程运行的返回值。
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
一般创建一个线程去运行需要实现Runnable，然后new Thread（Runnable），而Thread类没有以Callable接口为参的构造方法，那么该怎么运行实现了Callable接口的类呢？
二、Future和FutureTask
Future类源码：
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
原文：http://www.cnblogs.com/dolphin0520/p/3949310.html
在Future接口中声明了5个方法，下面依次解释每个方法的作用：
1、cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
2、isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
3、isDone方法表示任务是否已经完成，若任务完成，则返回true；
4、get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
5、get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
也就是说Future提供了三种功能：
1）判断任务是否完成；
2）能够中断任务；
3）能够获取任务执行结果。
因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。
FutureTask部分源码:
public class FutureTask<V> implements RunnableFuture<V>
FutureTask里面有两个构造方法，不过一般用第一个，至于为什么要有第二个构造方法，我认为是为了兼容以前的类，会把一个实现Runnable接口的类通过new RunnableAdapter<T>（Runnable task, T result)方法转化成Callable接口的类来继续运行。
public FutureTask(Callable<V> callable)
public FutureTask(Runnable runnable, V result){
this.callable = Executors.callable(runnable, result);
this.state = NEW;
}
而RunnableFuture接口又是继承自Runnable和Future：
public interface RunnableFuture<V> extends Runnable, Future<V>
所以FutureTask间接的实现了Future接口，并且为Future里面的5个抽象方法添加具体的实现。
三、Executors、Executor和ExecutorService
Executors：
一般用来创建指定的线程池：
1、创建指定线程数量的线程池：public static ExecutorService newFixedThreadPool(int n Threads)
2、创建只有一个线程的线程池：public static ExecutorService newSingleThreadExecutor()
3、创建可根据需要增加新线程的线程池：public static ExecutorService newCachedThreadPool()
4、创建一个可安排在给定延迟后运行命令或者定期地执行的线程池：public static ScheduledExecutorService newSingleThreadScheduledExecutor()
Executor:
public interface Executor {
void execute(Runnable command);
}
execute方法用于在线程池中运行指定的实现Runnable接口的线程。
ExecutorService部分源码：
public interface ExecutorService extends Executor {
void shutdown();
List<Runnable> shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
}
实例：
package callable;
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.TimeUnit;
import java.util.concurrent.TimeoutException;
public class C_F_test {
public static void main(String[] args) throws
TimeoutException, InterruptedException,
ExecutionException {
ExecutorService threadPool =
Executors.newCachedThreadPool();
Future<Integer> future1 = threadPool.submit(new
MyCallThread());
Future<Integer> future2 = threadPool.submit(new
MyCallThread());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程1是否计算完成? : " +
future1.isDone());
//cancel方法最终调用interrupt()方法，而当future1线程在sleep的时候被interrupt时就会抛异常,
//就会转向future1线程的异常处理模块
System.out.println("是否打断了子线程1 : " +
future1.cancel(true));
System.out.println("子线程1是否计算完成? : " +
future1.isDone());
// 被取消后的线程是无法取到其运行结果的值的，因为这个线程在取消后已经没数据了。
// System.out.println("当前计算的总和是 : " +
future1.get());
System.out.println("子线程2是否计算完成? : " +
future2.isDone());
System.out.println("子线程2的运行结果是 : " +
future2.get());
System.out.println("子线程2是否计算完成? : " +
future2.isDone());
threadPool.shutdownNow();
}
}
class MyCallThread implements Callable<Integer> {
@Override
public Integer call() throws Exception {
try {
int i, sum = 0;
for (i = 1; i <= 100; i++) {
sum += i;
TimeUnit.MILLISECONDS.sleep(100);
}
return sum;
} catch (InterruptedException e) {
//产生异常后当前线程就不是阻塞状态了,需要再次调用中断方法来中断当前线程(future1)
Thread.currentThread().interrupt();
}
return 0;
}
}
代码结果：
子线程1是否计算完成? : false
是否打断了子线程1 : true
子线程1是否计算完成? : true
子线程2是否计算完成? : false
子线程2的运行结果是 : 5050
子线程2是否计算完成? : true
如果在MyCallThread类里的catch块中没写Thread.currentThread().interrupt();就会抛异常，如下：
原因我在代码里写了：FutureTask类的cancel()方法最终会调用 interrupt方法，
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
UNSAFE.putOrderedInt(this, stateOffset,
INTERRUPTED);
}
而这时future1线程有很大可能在sleep，一旦被打断就会进入catch块处理，当前线程就会由阻塞状态(sleep)变成非阻塞状态（因为进入catch了，不在sleep了），
需要在catch块手动中断当前线程。
参考：
1、http://www.cnblogs.com/dolphin0520/p/3949310.html
2、https://blog.****.net/Androidlushangderen/article/details/54984681
3、https://blog.****.net/srzhz/article/details/6804756
4、https://blog.****.net/ghsau/article/details/7443324