java多线程
Java实现多线程有两种方式：一个是直接继承Thread类，一种是实现Runnable接口。但这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。
于是在jdk1.5后又增加了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。
Callable，Runnable，Futrue
1: Runnable是一个接口，位于java.lang包下，里面只声明了一个run()方法，但是run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。
package java.lang;
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
2: Callable是一个泛型接口，位于java.util.concurrent包下，在它里面只声明了一个call()方法，返回值是传入的泛型类型。
package java.util.concurrent;
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
3: Future也是一个泛型接口位于java.util.concurrent包下，它主要功能是对具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
package java.util.concurrent;
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;
}
（1） cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。
（2） isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
（3） isDone方法表示任务是否已经完成，若任务完成，则返回true；
（4） get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
（5） get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null
RunnableFuture, RunnableAdapter
1: Runnablefuture也是一个泛型接口位于java.util.concurrent包下,继承Runnable,Future,所以Runnablefuture是 Runnable和Future接口的统一
package java.util.concurrent;
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
2: RunnableAdapter
RunnableAdapter是 Exectors中的内部泛型类，实现Callable接口，主要用来转换Runnable类型为Callable类型。内部包含2个成员变量，一个是Runnable类型变量另一个是传入的泛型类型。
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
实际上Callable = Runnable + 泛型返回值 result
Thread，FutureTask
1: Thread是 java.lang包下的线程类实现了接口Runnable，是一个程序中执行任务的最小单元。只能执行实现了Runnable接口下的任务类。无法获取线程运行完后的结果。
package java.lang;
public class Thread implements Runnable {
2: FutureTask
2.1) Future只是一个接口，所以是无法直接用来创建对象使用，因此就有了FutureTask，FutureTask位于java.util.concurrent包下，并且是一个可以执行任务的线程类同时可以获取线程执行结束后的 返回值。它顶级接口是Runnable(FutureTask实现RunnableFuture, RunnableFuture继承Runnable和Future)，所以Thread可以执行FutureTask任务
package java.util.concurrent;
public class FutureTask<V> implements RunnableFuture<V> {
2.2) FutureTask有2个构造函数，一个接受Runnable + 返回值,一个接受Callable,但在接受了Runnable和返回值后会通过RunnableAdapter重新封装成Callable类型，然后赋值给成员变量callable。调用构造函数 FutureTask(Runnable runnable, V result)，然后构造函数再调用 Executors.callable，Executors.callable方法会创建一RunnableAdapter(包含一个runnable变量和一个泛型T的返回值变量)对象然后返回给FutureTask
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
Executors部分源码：
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
//new了一个RunnableAdapter,返回Callable,说明RunnableAdapter实现了Callable
return new RunnableAdapter<T>(task, result);
}
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
//Runnable task执行了run()
task.run();
//返回了T result
return result;
}
}
Thread状态与转换
使用案例
1：Futuretask使用案例
FutureTask fu = new FutureTask<>(new CallableResources(5));
Fu.run();
try {
if (fu.isCancelled()){
System.out.println("The task has been cancelled");
}else {
System.out.println("The task result is " + fu.get());
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
2：Thread + FutureTask使用案例
FutureTask<Integer> ft = new FutureTask<>(new CallableStudy());
FutureTask<Integer> ft2 = new FutureTask<>(new RunnableStudy(), 123);
Thread t1 = new Thread(ft);
Thread t2 = new Thread(ft2);
t1.start();
t2.start();
try {
int result = ft.get();
System.out.println("从计算线程拿到的结果为：" + result);
int result2 = ft2.get();
System.out.println("从计算线程拿到的结果为：" + result2);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
3：ExecutorService + FutureTask 使用案例
ExecutorService service = new ThreadPoolExecutor(1,2,10,TimeUnit.MINUTES,new ArrayBlockingQueue<>(5));
Future f = service.submit(fu);
try {
if (f.isCancelled()){
System.out.println("The task has been cancelled");
}else {
System.out.println("The task result is " + f.get());
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
