java并发基础篇（五）： 创建线程的四种方式
java并发基础篇（五）： 创建线程的四种方式
概述
线程的创建一共有四种方式：
- 继承于
Thread类，重写run（）方法； - 实现
Runable接口，实现里面的run（）方法； - 使用
FutureTask实现有返回结果的线程 - 使用
ExecutorService、Executors线程池。
在详细了解这四种方法之前，先来理解一下为什么线程要这样创建：形象点来说，Thread是一个工人，run（）方法里面的便是他的任务栏，这个任务栏默认是空的。当你想要这个线程做点什么时，你可以重写Thread里面的run方法，重写这个工人的任务栏；也可以通过runable、callable接口，从外部赋予这个工人任务。还可以将任务交给一堆工人，谁有空就谁就承担这个任务（线程池）。
一、四种方式的详细介绍
1、继承于Thread类，重写run（）方法
1Thread thread = new MyThread();
2 //线程启动
3thread.start();MyThread 类
1//继承Thread
2class MyThread extends Thread{
3 //重写run方法
4 @Override
5 public void run() {
6 //任务内容....
7 System.out.println("当前线程是："+Thread.currentThread().getName());
8 }
9}运行结果： 当前线程是：Thread-0
如果线程类使用的很少，那么可以使用匿名内部类，请看下面的例子：
1Thread thread = new Thread(){
2 @Override
3 public void run() {
4 //任务内容....
5 System.out.println("当前线程是："+Thread.currentThread().getName());
6 }
7 };2、实现Runable接口，实现里面的run（）方法：
第一种方法- -继承Thread类的方法，一般情况下是不建议用的，因为java是单继承结构，一旦继承了Thread类，就无法继承其他类了。所以建议使用 实现Runable接口 的方法；
1Thread thread = new Thread(new MyTask());
2 //线程启动
3thread.start();MyTask 类：
1//实现Runnable接口
2class MyTask implements Runnable{
3 //重写run方法
4 public void run() {
5 //任务内容....
6 System.out.println("当前线程是："+Thread.currentThread().getName());
7 }
8}同样，如果这个任务类（MyTask ）用的很少，也可以使用匿名内部类：
1Thread thread = new Thread(new Runnable() {
2 @Override
3 public void run() {
4 //任务内容....
5 System.out.println("当前线程是："+Thread.currentThread().getName());
6 }
7 });3、使用 FutureTask 实现有返回结果的线程
FutureTask 是一个可取消的异步计算任务，是一个独立的类，实现了 Future、Runnable接口。FutureTask 的出现是为了弥补 Thread 的不足而设计的,可以让程序员跟踪、获取任务的执行情况、计算结果 。
因为 FutureTask实现了 Runnable，所以 FutureTask 可以作为参数来创建一个新的线程来执行，也可以提交给 Executor 执行。FutureTask 一旦计算完成，就不能再重新开始或取消计算。
FutureTask的构造方法
可以接受 Runnable,Callable 的子类实例。
1//创建一个 FutureTask，一旦运行就执行给定的 Callable。
2public FutureTask(Callable<V> callable);
3//创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。
4public FutureTask(Runnable runnable, V result)
5FutureTask 的简单例子
1public class Test {
2 public static void main(String[] args) throws InterruptedException, ExecutionException {
3 FutureTask<Double> task = new FutureTask(new MyCallable());
4 //创建一个线程，异步计算结果
5 Thread thread = new Thread(task);
6 thread.start();
7 //主线程继续工作
8 Thread.sleep(1000);
9 System.out.println("主线程等待计算结果...");
10 //当需要用到异步计算的结果时，阻塞获取这个结果
11 Double d = task.get();
12 System.out.println("计算结果是："+d);
13 //用同一个 FutureTask 再起一个线程
14 Thread thread2 = new Thread(task);
15 thread2.start();
16}
17}
18class MyCallable implements Callable<Double>{
19 @Override
20 public Double call() {
21 double d = 0;
22 try {
23 System.out.println("异步计算开始.......");
24 d = Math.random()*10;
25 d += 1000;
26 Thread.sleep(2000);
27 System.out.println("异步计算结束.......");
28 } catch (InterruptedException e) {
29 e.printStackTrace();
30 }
31 return d;
32 }
33}运行结果： 异步计算开始……. 主线程等待计算结果… 异步计算结束……. 计算结果是：1002.7806590582911
四、使用线程池ExecutorSerice、Executors
前面三种方法，都是显式地创建一个线程，可以直接控制线程，如线程的优先级、线程是否是守护线程，线程何时启动等等。而第四种方法，则是创建一个线程池，池中可以有1个或多个线程，这些线程都是线程池去维护，控制程序员不需要关心这些细节，只需要将任务提交给线程池去处理便可，非常方便。
创建线程池的前提最好是你的任务量大，因为创建线程池的开销比创建一个线程大得多。
创建线程池的方式
ExecutorService是一个比较重要的接口，实现这个接口的子类有两个 ThreadPoolExecutor (普通线程池)、ScheduleThreadPoolExecutor (定时任务的线程池)。你可以通过这两个类来创建一个线程池，但要传入各种参数，不太方便。
为了方便用户，JDK中提供了工具类Executors，提供了几个创建常用的线程池的工厂方法。由于篇幅原因，不细说，可参考我的并发系列文章。
Executors 创建单线程的线程池
1public class MyTest {
2 public static void main(String[] args) {
3 //创建一个只有一个线程的线程池
4 ExecutorService executorService = Executors.newSingleThreadExecutor();
5 //创建任务，并提交任务到线程池中
6 executorService.execute(new MyRunable("任务1"));
7 executorService.execute(new MyRunable("任务2"));
8 executorService.execute(new MyRunable("任务3"));
9 }
10}
11class MyRunable implements Runnable{
12 private String taskName;
13 public MyRunable(String taskName) {
14 this.taskName = taskName;
15 }
16 @Override
17 public void run() {
18 System.out.println("线程池完成任务："+taskName);
19 }
20}二、关于run（）方法的思考
看看下面这种情况：线程类Thread 接收了外部任务，同时又用匿名内部类的方式重写了内部的run（）方法，这样岂不是有两个任务，那么究竟会执行那个任务呢？还是两个任务一起执行呢？
1Thread thread = new Thread(new MyTask()){
2 @Override
3 public void run() {//重写Thread类的run方法
4 System.out.println("Thread 类的run方法");
5 }
6 };
7 //线程启动
8 thread.start();1//实现Runnable接口
2class MyTask implements Runnable{
3 //重写run方法
4 @Override
5 public void run() {
6 //任务内容....
7 System.out.println("这是Runnable的run方法");
8 }
9}运行结果： Thread 类的run方法
通过上面的结果，可以看出：线程最后执行的是Thread类内部的run（）方法，这是为什么呢？我们先来分析一下JDK的Thread源码：
1private Runnable target;
2public void run() {
3 if (target != null) {
4 target.run();
5 }
6} 一切都清晰明了了，Thread类的run方法在没有重写的情况下，是判断一下是否有Runnable 对象传进来，如果有，那么就调用Runnable 对象里的run方法；否则，就什么都不干，线程结束。所以，针对上面的例子，一旦你继承重写了Thread类的run（）方法，而你又想可以接收Runable类的对象，那么就要加上super.run（），执行没有重写时的run方法，改造的例子如下：
1Thread thread = new Thread(new MyTask()){
2 @Override
3 public void run() {//重写Thread类的run方法
4 //调用父类Thread的run方法，即没有重写时的run方法
5 super.run();
6 System.out.println("Thread 类的run方法");
7 }
8 };运行结果： 这是Runnable的run方法 Thread 类的run方法
出处：http://www.cnblogs.com/jinggod/p/8485106.html