转自：http://blog.csdn.net/nugongahou110
从最简单的说起Thread和Runnable
说到并发编程，就一定是多个线程并发执行任务。那么并发编程的基础是什么呢？没错那就是Thread了。一个Thread可以执行一个Runnable类型的对象。那么Runnable是什么呢？其实Runnable是一个接口，他只定义了一个方法run（），这个run（）方法里就是我们要执行的任务，并且是要被Thread调用的。因此，一个Runnable就可以理解为一个要被执行的任务，而Thread就是一个执行任务的工人！
接下来我们用一个例子来实践一下，我们有一个任务（Runnable），这个任务就是来计算1+2+3+…+10，然后我们叫来一个工人（Thread）来执行这个任务。
public class ThreadDemo {
public static void main(String[] args) {
Thread worker = new Thread(new CountRunnable());
worker.start();
}
public static class CountRunnable implements Runnable{
private int sum;
@Override
public void run() {
for(int i=1 ; i<11 ; i++){
sum = sum+i;
}
System.out.println("sum="+sum);
}
}
}
这里我们调用了Thread的start()方法，相当于通知我们的工人去干活，然后工人Thread去调用任务Runnable的run（）方法去干活。
如果我们觉得一个工人不够用，那么我们可以多叫来几个工人，让他们一起来工作，这就是并发编程了！
public class ThreadDemo {
public static void main(String[] args) throws Exception{
List<Thread> threads = new ArrayList<Thread>();
for(int i=1 ; i<101 ; i++){
Thread thread = new Thread(new CountRunnable(),"Thread"+i);
threads.add(thread);
thread.start();
}
for(Thread t : threads){
t.join();
}
System.out.println("所有线程执行完毕！");
}
public static class CountRunnable implements Runnable{
private int sum;
@Override
public void run() {
for(int i=1 ; i<11 ; i++){
sum = sum+i;
}
System.out.println(Thread.currentThread().getName()+"执行完毕 sum="+sum);
}
}
}
我们看到，每个sum都等于55，不是听说多线程并发执行会带来线程不安全的问题吗？其实这里我们是给每个工人分配一个只属于自己的任务，每个工人干自己的活，所以并不会影响到其他的人
Thread thread = new Thread(new CountRunnable(),"Thread"+i);
那么什么情况下会出现线程并发的问题的？我们要做的就是把一个任务同时分配给100名工人，那么就会出现线程不安全的问题
public class ThreadDemo {
public static void main(String[] args) throws Exception{
List<Thread> threads = new ArrayList<Thread>();
//注意这里，我们在外面new出一个任务来，让100个线程都来执行这个任务
CountRunnable work = new CountRunnable();
for(int i=1 ; i<101; i++){
Thread thread = new Thread(work,"Thread"+i);
threads.add(thread);
}
for(Thread t : threads){
t.start();
}
for(Thread t : threads){
t.join();
}
System.out.println("所有线程执行完毕");
}
public static class CountRunnable implements Runnable{
private int sum;
@Override
public void run() {
for(int i=1 ; i<11 ; i++){
try {
//在这里我们让每个工人每进行一次加法运算后就休息1ms，这样会使得结果明显
TimeUnit.MILLISECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
sum = sum+i;
}
System.out.println(Thread.currentThread().getName()+"执行完毕 sum="+sum);
}
}
}
我们看到的结果简直不堪入目，正确结果应该是5500对吧，这时因为我们有100名工人去干一件任务，他们都操作的是同一个变量，因此多线程修改共享变量会出现问题，至于原理是什么，大家可以参考我的另一篇文章Java并发编程之图文解析volatile关键字来了解一下Java的内存模型（JMM）。
这篇文章的题目不是叫Future，FutureTask和Callable吗？我怎么连他们的影子都还没有见到？大家先别着急，还是和我一起慢慢深入，这样才能真正理解他们存在的道理。
最简单的方法出现了问题，线程池来解决
现在我们可以叫来这100名工人来为我们干活了，可是这样有个问题，这100名工人不是说找就找的，首先你得去发招聘启事，接着再去面试，再去培训等等，非常的费时费力，所以我们应该找到一个外包公司，比如我们需要100名工人，我们直接就到外包公司去借100名工人，直接来干活，这样就省了不少的力气了，这个外包公司就是线程池了。关于线程池的介绍，有一篇写的非常详细的博客Android性能优化之使用线程池处理异步任务，既然已经有人把它的理论总结的很清晰透彻了，我就不再重复去介绍一遍了，如果大家有对线程池的基础还不了解的话，推荐看看这篇文章。下面我就来说说线程池的使用，慢慢引出Future和Callable。
我们在使用线程池的时候，可以把一个任务（Runnable）交给线程池，调用线程池的execute(runnable)来执行
public class ExecutorDemo {
public static void main(String[] args) {
ExecutorService es = Executors.newSingleThreadExecutor();
CountRunnable work = new CountRunnable();
es.execute(work);
es.shutdown();
System.out.println("任务结束"+es.isShutdown());
}
public static class CountRunnable implements Runnable{
private int sum;
@Override
public void run() {
for(int i=1 ; i<11 ; i++){
sum+=i;
}
System.out.println("sum="+sum);
}
}
}
不知道大家有没有发现一个问题，我们执行Runnable任务，他的run（）方法是没有返回值的，那如果我们想要执行完一个任务，并且能够拿到一个返回值结果，那么应该怎么做呢？
Future登场
当当当！没错！主角就要登场了！首先介绍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;
}
Future是一个接口，他提供给了我们方法来检测当前的任务是否已经结束，还可以等待任务结束并且拿到一个结果，通过调用Future的get（）方法可以当任务结束后返回一个结果值，如果工作没有结束，则会阻塞当前线程，直到任务执行完毕，我们可以通过调用cancel（）方法来停止一个任务，如果任务已经停止，则cancel（）方法会返回true；如果任务已经完成或者已经停止了或者这个任务无法停止，则cancel（）会返回一个false。当一个任务被成功停止后，他无法再次执行。isDone（）和isCancel（）方法可以判断当前工作是否完成和是否取消。
简单介绍一番，我们发现原来那些工人，只会去执行工作，做完工作之后也不给我们反馈信息，并且我们也不知道他们何时能完工，更不能打断他们的工作，这种工人的弊端就显现出来了。
现在我们有了更高级的工人，这些工人只能是从外包公司来借（利用线程池），当这些工人干完活之后，他们会给我们返回运行的结果，而且我们还可以暂停他们的工作。
我们看到线程池还有一个方法可以执行一个任务，那就是submit（）方法
public Future<?> submit(Runnable task) {
return e.submit(task);
}我们看到他会返回一个Future对象，这个Future对象的泛型里还用的是一个问号“？”，问号就是说我们不知道要返回的对象是什么类型，那么就返回一个null好了，因为我们执行的是一个Runnable对象，Runnable是没有返回值的，所以这里用一个问号，说明没有返回值，那么就返回一个null好了。
public class ExecutorDemo {
public static void main(String[] args) {
ExecutorService es = Executors.newSingleThreadExecutor();
CountRunnable work = new CountRunnable();
Future<?> future = es.submit(work);
System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
for(int i=0 ; i<10 ; i++){
try {
TimeUnit.SECONDS.sleep(1);
System.out.println("主线程"+Thread.currentThread().getName()+"仍然可以执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Object object = future.get();
System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+" result="+object);
} catch (Exception e) {
e.printStackTrace();
}
es.shutdown();
System.out.println("关闭线程池"+es.isShutdown());
}
public static class CountRunnable implements Runnable{
private int sum;
@Override
public void run() {
for(int i=1 ; i<11 ; i++){
try {
TimeUnit.MILLISECONDS.sleep(1000);
sum+=i;
System.out.println("工作线程"+Thread.currentThread().getName()+"正在执行 sum="+sum);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
我们看到Future有一个get（）方法，这个方法是一个阻塞方法，我们调用submit（）执行一个任务的时候，会执行Runnable中的run（）方法，当run（）方法没有执行完的时候，这个工人就会歇着了，直到run（）方法执行结束后，工人就会立即将结果取回并且交给我们。我们看到返回的result=null。那既然返回null的话还有什么意义呢？？别着急，那就要用到Callable接口了
Callable登场
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;
}我们看到Callable接口和Runnable接口很像，也是只有一个方法，不过这个call（）方法是有返回值的，这个返回值是一个泛型，也就是说我们可以根据我们的需求来指定我们要返回的result的类型
public class CallableDemo {
public static void main(String[] args) throws Exception{
ExecutorService es = Executors.newSingleThreadExecutor();
Future<Number> future = es.submit(new CountCallable());
System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
Number number = future.get();
System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
if(future.isDone()){
System.out.println("任务执行完毕 result="+number.num);
es.shutdown();
}
}
public static class CountCallable implements Callable<Number>{
@Override
public Number call() throws Exception {
Number number = new Number();
TimeUnit.SECONDS.sleep(2);
number.setNum(10);
return number;
}
}
static class Number{
private int num;
private int getNum(){
return num;
}
private void setNum(int num){
this.num = num;
}
}
}我们创建我们的任务（Callable）的时候，传入了一个Number类的泛型，那么在call（）方法中就会返回这个Number类型的对象，最后在Future的get（）方法中就会返回我们的Number类型的结果。
然而Future不仅仅可以获得一个结果，他还可以被取消，我们通过调用future的cancel（）方法，可以取消一个Future的执行
public class CallableDemo {
public static void main(String[] args) throws Exception{
ExecutorService es = Executors.newSingleThreadExecutor();
Future<Number> future = es.submit(new CountCallable());
System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
future.cancel(true);
if (future.isCancelled()) {
System.out.println("任务被取消于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
es.shutdownNow();
}else{
Number number = future.get();
System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
if(future.isDone()){
System.out.println("任务执行完毕 result="+number.num);
es.shutdown();
}
}
}
public static class CountCallable implements Callable<Number>{
@Override
public Number call() throws Exception {
Number number = new Number();
TimeUnit.SECONDS.sleep(5);
number.setNum(10);
return number;
}
}
static class Number{
private int num;
private int getNum(){
return num;
}
private void setNum(int num){
this.num = num;
}
}
}
FutureTask登场
说完了Future和Callable，我们再来说最后一个FutureTask，Future是一个接口，他的唯一实现类就是FutureTask，其实FutureTask的一个很好地特点是他有一个回调函数done（）方法，当一个任务执行结束后，会回调这个done（）方法，我们可以在done（）方法中调用FutureTask的get（）方法来获得计算的结果。为什么我们要在done（）方法中去调用get（）方法呢？ 这是有原因的，我在Android开发中，如果我在主线程去调用futureTask.get()方法时，会阻塞我的UI线程，如果在done（）方法里调用get（），则不会阻塞我们的UI线程。
public class FutureTask<V> implements RunnableFuture<V> {
}我们来看看FutureTask实现了RunnableFuture接口
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}Runnable接口又实现了Runnable和Future接口，所以说FutureTask可以交给Executor执行，也可以由调用线程直接执行FutureTask.run（）方法。FutureTask的run（）方法中又会调用Callable的call（）方法
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
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);
}
}所以一个FutureTask实际上执行的是一个Callable类型实例的call（）方法，call()方法才是我们的最终任务。其实Android中的AsyncTask内部也是使用的FutureTask，我们写一个小的例子来模仿AsyncTask的可以停止的功能
public class MainActivity extends AppCompatActivity {
FutureTask<Number> futureTask;
CountCallable countCallable;
ExecutorService es;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
countCallable = new CountCallable();
futureTask = new FutureTask<Number>(countCallable){
@Override
protected void done() {
try {
Number number = futureTask.get();
Log.i("zhangqi", "任务结束于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()) + " result=" + number.getNum());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (CancellationException e) {
Log.i("zhangqi", "任务被取消于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()));
}
}
};
es = Executors.newFixedThreadPool(2);
es.execute(futureTask);
Log.i("zhangqi", "任务被开始于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()));
}
public void cancel(View view) {
futureTask.cancel(true);
}
public static class CountCallable implements Callable<Number> {
@Override
public Number call() throws Exception {
Number number = new Number();
Log.i("zhangqi","运行在"+Thread.currentThread().getName());
Thread.sleep(5000);
number.setNum(10);
return number;
}
}
static class Number {
private int num;
private int getNum() {
return num;
}
private void setNum(int num) {
this.num = num;
}
}
}
我们写了一个CountCallable类，在call（）方法里是我们要执行的任务，最终我们的任务要返回一个Number类型的对象，我们在call（）方法中首先会让线程睡眠5秒钟，然后new出一个Number对象并且给他赋值为10.
接着我们new一个FutureTask并且把我们的CountCallable对象传入进去，FutureTask的泛型就是我们要返回的结果的类型，并且我们要重写FutureTask的done（）方法，这个方法会在任务结束后自动执行，在done（）方法中我们调用get（）方法获得运行的结果 
现在我们执行cancel方法，来结束这个FutureTask任务 
在任务执行2秒的时候，我点击了cancel按钮，执行了FutureTask的cancel方法，当我们执行了cancel（）方法后，FutureTask的get（）方法会抛出CancellationException异常，我们捕捉这个异常，然后在这里来处理一些后事 =-=！
相信大家都已经理解了为什么Java要提供给我们Future，FutureTask和Callable了，他们其实是并发编程中更高级的应用，我们应该理解他们并且正确的使用它们。