Android(java)学习笔记66:实现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();
}
}
}

执行结果,如下:

Android(java)学习笔记66:实现Runnable接口创建线程 和 使用Callable和Future创建线程

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();
}
}
}

运行效果,如下:

Android(java)学习笔记66:实现Runnable接口创建线程 和 使用Callable和Future创建线程

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

4. 总结:

实现多线程的方式:3种

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

    问题
           a为什么要重写run()方法?
              run()里面封装的是被线程执行的代码
           b启动线程对象要哪个方法?
          start()
           crun()和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适合多个相同程序代码去处理同一个资源的情况,把线程同程序的代码、数据有效分离,较好的体现了面向对象的设计思想。

   

上一篇:Unity3D 创建动态的立方体图系统


下一篇:NOIP200805 笨小猴(低效算法)(一大桶水)【A006】