多线程的创建方式

1）、继承 Thread 类：但 Thread 本质上也是实现了 Runnable 接口的一个实例，它代表一个线程的实例，并
且，启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线
程，并执行 run()方法。这种方式实现多线程很简单，通过自己的类直接 extend Thread，并复写 run()方法，就可以

启动新线程并执行自己定义的 run()方法。例如：继承 Thread 类实现多线程，并在合适的地方启动线程

1．public class MyThread extends Thread {
2． public void run() {
3． System.out.println("MyThread.run()");
4． }
5．}
6．MyThread myThread1 = new MyThread();
7．MyThread myThread2 = new MyThread();
8．myThread1.start();

9．myThread2.start();

（2）、实现 Runnable 接口的方式实现多线程，并且实例化 Thread，传入自己的 Thread 实例，调用 run( )方法

1．public class MyThread implements Runnable {
2． public void run() {
3． System.out.println("MyThread.run()");
4． }
5．}
6．MyThread myThread = new MyThread();
7．Thread thread = new Thread(myThread);

8．thread.start();

（3）、使用 ExecutorService、Callable、Future 实现有返回结果的多线程：ExecutorService、Callable、Future
这 个 对 象 实 际 上 都 是 属 于 Executor 框 架 中 的 功 能 类 。 想 要 详 细 了 解 Executor 框 架 的 可 以 访 问
http://www.javaeye.com/topic/366591 ，这里面对该框架做了很详细的解释。返回结果的线程是在 JDK1.5 中引入
的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。
可返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口。执行 Callable 任务后，可以
获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了，再结合线程池接口
ExecutorService 就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在

JDK1.5 下验证过没问题可以直接使用。代码如下：

1．import java.util.concurrent.*;
2．import java.util.Date;
3．import java.util.List;
4．import java.util.ArrayList;
5．
6．/**
7．* 有返回值的线程
8．*/
9．@SuppressWarnings("unchecked")
10．public class Test {
11．public static void main(String[] args) throws ExecutionException,
12． InterruptedException {
13． System.out.println("----程序开始运行----");
14． Date date1 = new Date();
15．
16． int taskSize = 5;
17． // 创建一个线程池
18． ExecutorService pool = Executors.newFixedThreadPool(taskSize);
19． // 创建多个有返回值的任务
20． List<Future> list = new ArrayList<Future>();
21． for (int i = 0; i < taskSize; i++) {
22． Callable c = new MyCallable(i + " ");
23． // 执行任务并获取 Future 对象
24． Future f = pool.submit(c);
25． // System.out.println(">>>" + f.get().toString());
26． list.add(f);
27． }
28． // 关闭线程池
29． pool.shutdown();
30．
31． // 获取所有并发任务的运行结果
32． for (Future f : list) {
33． // 从 Future 对象上获取任务的返回值，并输出到控制台
34． System.out.println(">>>" + f.get().toString());
35． }
36．
37． Date date2 = new Date();
38． System.out.println("----程序结束运行----，程序运行时间【"
39． + (date2.getTime() - date1.getTime()) + "毫秒】");
40．}
41．}
42．
43．class MyCallable implements Callable<Object> {
44．private String taskNum;
45．
46．MyCallable(String taskNum) {
47． this.taskNum = taskNum;
48．}
49．
50．public Object call() throws Exception {
51． System.out.println(">>>" + taskNum + "任务启动");
52． Date dateTmp1 = new Date();
53． Thread.sleep(1000);
54． Date dateTmp2 = new Date();
55． long time = dateTmp2.getTime() - dateTmp1.getTime();
56． System.out.println(">>>" + taskNum + "任务终止");
57． return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
58．}
59．}