Java并发编程：如何创建线程？
在 Java 中创建线程的方式有两种：1）继承 Thread 类 2）实现 Runnable 接口 3）实现 FutureTask 接口
前两种方式创建的线程都无法获取线程的执行结果，而通过 FutureTask 方式实现的线程可以获取线程执行的结果。
一、继承Thread类
package com.chanshuyi.thread;
public class ThreadDemo1 {
public static void main(String[] args) {
new MyThread().start();
}
}
class MyThread extends Thread{
@Override
public void run(){
System.out.println("Hello, I'm Thread Constructured by Thread");
}
}如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。
当然，你也可以使用匿名类的方式书写。
package com.chanshuyi.thread;
public class ThreadDemo2 {
public static void main(String[] args) {
new Thread(){
@Override
public void run(){
System.out.println("Hello, I'm Thread Constructured by anonymous Thread.");
}
}.start();
}
}二、实现Runnable接口
该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。
package com.chanshuyi.thread;
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Hello, I'm Thread Constructured by Runnable");
}
}
public class ThreadDemo {
public static void main(String[] args) {
new Thread(new MyRunnable()).start();
}
}当然了，其实你也可以用匿名函数的写法，这种写法更加面向对象，推荐使用这种写法
package com.chanshuyi.thread;
public class ThreadDemo4 {
public static void main(String[] args) {
new Thread(new Runnable(){
@Override
public void run(){
System.out.println("Hello, I'm Thread Constructured by anonymous Runnable");
}
}).start();
}
}三、两种实现方式的区别
相信以上两种创建新线程的方式大家都很熟悉了，那么 Thread 和 Runnable 之间到底是什么关系呢？我们首先来看一下下面这个例子。
package com.chanshuyi.thread;
public class ThreadDemo5 {
public static void main(String args[]){
//输出：Thread is Running.
new Thread( //放在new Thread()括号中的new Runnable，其实是构造了一个实现了Runnable接口的类
new Runnable(){
public void run() {
while(true){
System.out.println("Runnable is Running.");
try{
Thread.sleep(1000);
}
catch(Exception e){
e.printStackTrace();
}
}
}
}
){ //放再new Thread{}内的方法，其实是构建了一个继承了Thread类的子类
public void run() {
while(true){
System.out.println("Thread is Running.");
try{
Thread.sleep(1000);
}
catch(Exception e){
e.printStackTrace();
}
}
}
}.start();
}
}在这里我们即使用了一个继承Thread类的子类，又在此子类的声明中传入了实现了Runnable对象的类的实例，那么这个例子可以创建一个线程吗？
可以的话，那么新的线程到底执行哪一个方法体里的数据？
答案是执行继承了Thread类的子类中的run()方法，具体原因需要追溯到Thread类的源码里，这里就不深入研究了。你只要记住，如果哪个变态的面试官丢这道题给你，你就要记得是执行的是继承了Thread类的子类（MyThread）的run()方法！即上面打出的日志是：Thread is Running.
四、实现 FutureTask 接口
其实除了继承 Thread 类和 实现 Runnable 接口可以实现线程之外，还可以通过 FutureTask 接口实现线程，这种方式与前两种的区别是它可以得到线程执行的返回值。
1）Callable 与 Runnable
先说一下java.lang.Runnable吧，它是一个接口，在它里面只声明了一个run()方法：
public interface Runnable {
public abstract void run();
}由于run()方法返回值为void类型，所以在执行完任务之后无法返回任何结果。
Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做call()：
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;
}可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。
2）Future
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
Future类位于java.util.concurrent包下，它是一个接口：
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接口中声明了5个方法，下面依次解释每个方法的作用：
- cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
- isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
- isDone方法表示任务是否已经完成，若任务完成，则返回true；
- get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
- get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
也就是说Future提供了三种功能：
1）判断任务是否完成；
2）能够中断任务；
3）能够获取任务执行结果。
因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。
3）FutureTask
我们先来看一下FutureTask的实现：
public class FutureTask<V> implements RunnableFuture<V>FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
FutureTask提供了2个构造器：
public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}事实上，FutureTask是Future接口的一个唯一实现类。
4）使用实例
上面说到 Callable 与 Runnable 的区别之一就是：Callable 可以返回线程的执行结果，而 Runnable 不可以。而从上面我们知道：Callable 接口是具体执行体，而 Task 接口则用于获取执行结果。那么 Callable 到底怎么用呢？
一般情况下，Callable 需要与 Thread 或 ExecutorService 配合使用。
1、Callable、Future 配合 Thread 使用
一般情况下都是用 FutureTask 来包装 Runnable 实例对象，之后在将 FutureTask 对象作为 Thread 类接口。
class Task implements Callable<String>{
@Override
public String call() throws Exception {
return "Hello Callable.";
}
}
public class CallableThread {
public static void main(String args[]) {
Task task = new Task();
FutureTask<String> futureTask = new FutureTask<>(task);
Thread thread = new Thread(futureTask);
thread.start();
try {
System.out.println("Result:" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}2、Callable、Future 配合 ExecutorService 使用
配合 ExecutorService 使用有两种方式，一种是用 FutureTask 包装 Runnable 实例对象，之后作为 submit 方法参数。另一种是直接将 Runnable 实例对象作为 submit 方法参数，而用 Future 对象接收返回结果。
class Task implements Callable<String>{
@Override
public String call() throws Exception {
return "Hello Callable.";
}
}
public class CallableThread {
public static void main(String args[]) {
//第1种方式
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
FutureTask<String> futureTask = new FutureTask<>(task);
executor.submit(futureTask);
executor.shutdown();
//第2种方式
ExecutorService executor = Executors.newCachedThreadPool();
Task task = new Task();
Future<String> futureTask = executor.submit(task);
executor.shutdown();
try {
System.out.println("Result:" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}从上面两种方式知道，无论采用哪种方式，传进 Thread 或 ExecutorService 里的参数都是 Runnable 类型的，而接收返回结果的都是 Future 类型对象。
参考资料：
http://www.cnblogs.com/lwbqqyumidi/p/3804883.html
http://www.cnblogs.com/mengdd/archive/2013/02/20/2917966.html