Android（java）学习笔记6：实现Runnable接口创建线程 和 使用Callable和Future创建线程

1. 前面说的线程的实现是新写一个子类继承Thread：

是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例

2. 这里说的方案2是指实现一个接口：

是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

这里我们主要说明2的实现方式…………

 package cn.itcast_05;
 public class MyRunnable implements Runnable {
     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             // 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
             System.out.println(Thread.currentThread().getName() + ":" + x);
         }
     }
 }

 package cn.itcast_05;
 /*
  * 方式2：实现Runnable接口
  * 步骤：
  *         A:自定义类MyRunnable实现Runnable接口
  *         B:重写run()方法
  *         C:创建MyRunnable类的对象
  *         D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
  */
 public class MyRunnableDemo {
     public static void main(String[] args) {
         // 创建MyRunnable类的对象
         MyRunnable my = new MyRunnable();
         // 创建Thread类的对象，并把C步骤的对象作为构造参数传递
         // Thread(Runnable target)
         // Thread t1 = new Thread(my);
         // Thread t2 = new Thread(my);
         // t1.setName("林青霞");
         // t2.setName("刘意");
         // Thread(Runnable target, String name)
         Thread t1 = new Thread(my, "林青霞");
         Thread t2 = new Thread(my, "刘意");
         t1.start();
         t2.start();
     }
 }

3. 方案3：使用Callable和Future创建线程

　　前面实现Runnable接口创建多线程时候，Thread类的作用是把run（）方法包装成线程执行体。那么是否可以直接把任意方法都包装成线程执行体呢?

Java目前不行的，但是Java的模仿者C#可以（C#可以将任意方法包装成线程执行体，包括有返回值的方法）

　　也许受此启发，从Java5开始，Java提供了Callable接口，该接口可以看成是Runnable接口的增强版，Callable接口提供了一个call（）方法可以作为线程执行体，但是call（）方法比run（）方法功能更加强大。

• call（）方法可以有返回值。
• call（）方法可以声明抛出异常

因此完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是该Callable对象的call（）方法。

　　问题是：Callable接口是Java 5新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。而且call（）方法还有一个返回值---call（）方法并不是直接调用的，它是作为线程执行体被调用的，那么如何获取call（）方法的返回值呢?

Java 5提供了Future接口来代表Callable接口里call（）方法的返回值，并为Future接口提供一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口---可以作为Thread类的target。

　　在Future接口里定义了如下几个公共方法来控制它关联的Callable任务：

• boolean cancel（boolean mayInterruptIfRunning）：试图取消该Future里关联的Callable任务。
• V get（）：返回Callable任务里面call（）方法的返回值。调用该方法将导致程序阻塞，必须等到子线程结束之后才会得到返回值
• V get（long timeout， TimeUnit unit）：返回Callable任务里call（）方法的返回值。该方法让程序最长阻塞时间由timeout 和 unit指定的时间，如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException异常
• boolean isCancelled（）：如果在Callable任务正常完成前取消，则返回true。
• boolean isDone（）：如果Callable任务已完成，则返回true。

使用Callable和Future创建线程的步骤：

（1）创建Callable接口实现类，并实现call（）方法，该call（）方法将作为线程执行体，且该call（）方法有返回值，在创建Callable实现类的实例。

（2）使用FutureTask类包装Callable对象，该FutureTask对象封装了该Callable对象的call（）方法的返回值

（3）使用FutureTask对象作为Thread对象target创建并启动新线程。

（4）调用FutureTask对象的get（）方法来获得子线程执行结束后的返回值

示例1：

 package com.himi.threadcallable;
 import java.util.Random;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
 public class CallableAndFutureDemo1 {
     public static void main(String[] args) {
         Callable<Integer> callable = new Callable<Integer>() {
             public Integer call() throws Exception {
                 return new Random().nextInt(100);
             }
         };
         FutureTask<Integer> future = new FutureTask<Integer>(callable);
         new Thread(future).start();
         try {
             Thread.sleep(5000);// 可能做一些事情
             System.out.println(future.get());//子线程执行结束，获取返回值
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }

执行结果，如下：

FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值，那么这个组合的使用有什么好处呢？假设有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用这个组合，用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到，岂不美哉！

示例2：

 package com.himi.threadcallable;
 import java.util.Random;
 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;
 public class CallableAndFutureDemo2 {
     public static void main(String[] args) {
         ExecutorService threadPool = Executors.newSingleThreadExecutor();
         Future<Integer> future = threadPool.submit(new Callable<Integer>() {
             public Integer call() throws Exception {
                 return new Random().nextInt(100);
             }
         });
         try {
             Thread.sleep(5000);// 可能做一些事情
             System.out.println(future.get());
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }
     }
 }

运行效果，如下：

代码是不是简化了很多，ExecutorService继承自Executor，它的目的是为我们管理Thread对象，从而简化并发编程，Executor使我们无需显示的去管理线程的生命周期，是JDK 5之后启动任务的首选方式。 

4. 总结：

实现多线程的方式：3种

• 方式1：继承Thread类
　　　　    A：自定义类MyThread继承Thread类
　　　　    B：在MyThread类中重写run().
　　　　    C：创建MyThread类的对象.
　　　　    D： 启动线程对象

    问题
           a：为什么要重写run()方法？
　　            run()里面封装的是被线程执行的代码
           b：启动线程对象要哪个方法？
　　　　      start()
           c：run()和start()方法的区别？
　               run()直接调用的仅仅是普通方法
                  start()先启动线程，再由JVM调用run()方法

• 方式2：实现Runnable接口
　　　 A：自定义类MyRunnable实现Runnable接口.
            B：在MyRunnable里面重写run()
            C：创建MyRunnable类的对象
            D：创建Thread类的对象，并把C步骤的对象作为构造参数传递

• 方式3：使用Callable 和 Future创建线程

　　　　步骤在上面。

    问题来了1：有了方式1，为什么还来方式2呢 ?
　　  a：可以避免由于Java单继承带来的局限性.
         b：适合多个相同程序代码去处理同一个资源的情况，把线程同程序的代码、数据有效分离，较好的体现了面向对象的设计思想。