需求： 我们要计算1+…+10和20+…+30相加的结果，当然可以用a=1+…+10，b=20+…+30，之后resutl=a+b。 但实际上第一个任务A和第二个任务B互不影响， 我们可以使用多线程的方法，将任务A和任务B并行执行，最后将两个任务的执行结果相加。那这样怎么用java实现呢？
1.实现的多种方法
第一种方法
首先分析一下需求，实际上A、B任务没有任何关联，所以我们可以直接使用多线程的方式，只不过由于线程什么时候运行结束，我们并不知道，所以这里先简单采取sleep，但是大家需要知道，这样是不对的，因为这个时间并非固定的。
public class Test {
public static void main(String[] args) {
Task task = new Task(1, 10);
task.start();
Task task1 = new Task(11, 20);
task1.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(task.result + task1.result);
}
public static class Task extends Thread {
int start;
int end;
int result = 0;
public Task(int start, int end) {
this.start = start;
this.end = end;
}
public void run() {
int i = start;
result = 0;
while (i <= end) {
result += i;
i++;
}
}
}
}第二种方法
既然第一种实现方法里面，有弊端的地方就是sleep，因为我们不知道两个线程啥时候结束，大家记得多线程知识章节，我们讲到过CountDownLatch吗？CountDownLatch是AQS的一种共享锁的具体实现，可以让当前线程阻塞，等待N个线程运行完成之后，才可继续运行。
import java.util.concurrent.CountDownLatch;
public class Test {
static int result = 0;
static CountDownLatch countDownLatch = new CountDownLatch(10);
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Task task = new Task(i * 10 + 1, (i + 1) * 10);
task.start();
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(result);
}
public static class Task extends Thread {
int start;
int end;
public Task(int start, int end) {
this.start = start;
this.end = end;
}
public void run() {
int i = start;
while (i <= end) {
result += i;
i++;
}
countDownLatch.countDown();
}
}
}
第三种方法
其实上面说到底，是因为Runnable没有返回值导致的，如果线程本身有阻塞的功能，也就是说在运行完成之前，get是阻塞的，那么就可以达到目的了。
Java其实已经给我们提供了这样的API，就是FutureTask，可以看一下FutureTask的类继承和实现关系。
public class FutureTask<V> implements RunnableFuture<V> {
}
public interface RunnableFuture<V> extends Runnable, Future<V> {
}
从这里看出FutureTask实际上就是一个Runnable而已，只不过它的绝妙点在于，get是阻塞式的，也就是未运行完成之前，get会阻塞。稍后总结环节，我们再来看FutureTask如何做到这点的？我们先来看实际使用。
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Test {
public static void main(String[] args) throws Exception {
System.out.println(Thread.currentThread().getName());
int result = 0;
for (int i = 0; i < 10; i++) {
FutureTask<Integer> futureTask = new FutureTask<Integer>(
new Callabled(i * 10 + 1, (i + 1) * 10));
new Thread(futureTask).start();
result += futureTask.get();
}
System.out.println(result);
}
public static class Callabled implements Callable<Integer> {
int start;
int end;
public Callabled(int start, int end) {
this.start = start;
this.end = end;
}
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
int result = 0;
while (start <= end) {
result += start;
start++;
}
return result;
}
}
}运行结果为：
main
Thread-0
Thread-1
Thread-2
Thread-3
Thread-4
Thread-5
Thread-6
Thread-7
Thread-8
Thread-9
50502.FutureTask原理
2.1 异同对比
首先通过上面的需求实践，大家其实已经知道了我们平常经常用的Runnable与FutureTask的区别了。
- 相同点：Runnable和FutureTask都是并发线程执行任务；
- 不同点：
1）FutureTask在线程运行完成之前（可以是结果返回、也可以是中断），是会一直阻塞当前线程的，只要您调用了它的get方法；
2）Runnable实现接口，只是一个run方法， 并不会阻塞当前线程，而且您也不能获取线程的运行结果；
2.2 状态定义
FutureTask既然要做到运行完成之前，一旦调用get就会阻塞当前线程，那么必然内部肯定维护了状态。我们看一下状态定义源码
rivate static final int NEW = 0;
private static final int COMPLETING = 1;
private static final int NORMAL = 2;
private static final int EXCEPTIONAL = 3;
private static final int CANCELLED = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED = 6;《Java并发编程的艺术》一本书中，根据FutureTask.run()方法的执行的时机，把FutureTask的运行状态分为三个阶段
- 未启动：FutureTask.run()方法还没有被执行之前，FutureTask处于未启动状态
- 已启动：FutureTask.run()方法执行之后，处于已启动状态。
- 已完成：FutureTask.run()方法执行结束，或者调用FutureTask.cancel(…)方法取消任务，或者在执行任务期间抛出异常，这些情况都称之为FutureTask的已完成状态。
FutureTask的类继承和实现关系。
public class FutureTask<V> implements RunnableFuture<V> {
}
public interface RunnableFuture<V> extends Runnable, Future<V> {
}
从这里看出FutureTask实际上就是一个Runnable而已，我们继续看一下它的构造函数
//Callable是什么？有Callable源码可知，实际上就是一个同步返回的接口定义而已，这里为什么传一个Callable进来呢？稍后我们再来解答
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
//我们可以直接把runnable传入，希望得到的运行结果传入
public FutureTask(Runnable runnable, V result) {
//此处源码会将我们传入的runnable和result，组合为callable接口实现
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
//可以看到Callable只是一个同步返回的功能接口定义而已
public interface Callable<V> {
V call() throws Exception;
}
2.3 run方法
我们接下来看一下，FutureTask的run方法
public void run() {
//如果state不是新建，也就是已启动或者已完成，则return
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
//callable我们传入的具体实现操作
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//调用callable的call方法， 也就是调用我们外部定义的具体实现操作，获取结果
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
//如果运行完成，则设置结果
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}这里也许大家有点迷糊了，callable到底是个啥？实际上，细心的小伙伴已经发行了，callable不就是我们外部定义的具体线程执行操作吗？
//使用
FutureTask<Integer> futureTask = new FutureTask<Integer>(
new Callabled(start, end));
public static class Callabled implements Callable<Integer> {
int start;
int end;
public Callabled(int start, int end) {
this.start = start;
this.end = end;
}
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
int result = 0;
while (start <= end) {
result += start;
start++;
}
return result;
}
}从上面源码可以看到，FutureTask的run会将callable的运行结果保存下来，那么关键来了，get是如何阻塞的？
2.4 get方法
大家可以先想一下，如果自己实现，该如何做？我的头脑风暴过程是这样的：
1）上面已经有了这个线程运行的几种状态的定义，那么在callable的call结果返回之前 or 中断异常抛出之前，那么状态就是COMPLETING之前的状态。那我自己get的时候，判断当前FutureTask的内部状态，如果<=COMPLETING，那么直接线程等待？
2）这里关键问题来了，线程如何等待？目前我自己想的话，是写一个死循环，每次sleep固定的时间，例如10ms，然后判断状态是否是完成了，如果没有，则继续sleep 10ms，每隔10ms线程重新进入就绪状态，排队获取cpu时间片，直到完成。
我们接下来看一下关键FutureTask的get方法如何实现的。
public V get() throws InterruptedException, ExecutionException {
int s = state;
//如果状态小于等于COMPLETING，则进入awaitDone
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
private int awaitDone(boolean timed, long nanos)
//timeed上面传入为false，nanos为0
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//...省略若干
else
//代码会走到这里
LockSupport.park(this);
}
}LockSupport.park(this);这里我们看到它的wait实现调用了这个方法，这个是干嘛的？和sleep的区别是？我们来通过一张图回顾一下线程的几种状态。
这里篇幅所限，就不详细展开了，各位有兴趣的小伙伴，可以自行搜索，或者看一下文章末尾的一篇文章链接。
LockSupport.park()休眠线程，LockSupport.unpark()唤醒线程，两个方法配合使用。也可以通过LockSupport.parkNanos()指定休眠时间后，自动唤醒。LockSupport.park()不会释放monitor锁。LockSupport.park()可以响应中断。
LockSupport.park()会是线程进入WAITING状态，而LockSupport.parkNanos(long nanos) 会进入TIMED_WAITING状态。
我们看一下，LockSupport.unpark()唤醒线程是在哪里做的？
//run中运行结果获取之后，会调用set方法
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
//取消方法
public boolean cancel(boolean mayInterruptIfRunning) {
//...
try { // in case call to interrupt throws exception
//...
} finally {
finishCompletion();
}
return true;
}
private void finishCompletion() {
// assert state > COMPLETING;
//...省略若干
LockSupport.unpark(t);
//...
}大家发现没有，LockSupport很像wait+sleep达到的效果，因为它不会释放锁，同时又必须成对去唤醒才可以。
课后作业
提一个需求，大家不要参考任何代码的前提下，自己实现一下，多线程下载一个文件，可以指定开启多少个线程，简单一点，对于客户来说，调用的接口就是输入两个参数，一个下载文件的url，一个是多少个线程。还有就是需要可以注册下载进度回调监听。
