线程创建的四种方式详解

概述：

Java 使用 Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。Java 可以用四种方式来创建线程，如下所示：

Java 使用 Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。Java 可以用四种方式来创建线程，如下所示：
Java 使用 Thread 类代表线程，所有的线程对象都必须是 Thread 类或其子类的实例。Java 可以用四种方式来创建线程，如下所示：

继承 Thread 类创建线程
实现 Runnable 接口创建线程
使用 Callable 和 Future 创建线程
使用线程池例如用 Executor 框架

详解

继承 Thread 类创建线程

主要步骤为：

定义 Thread 类的子类，并重写该类的 run()方法，该方法的方法体就是线程需要完成的业务代码任务，run()方法也称为线程的执行体
创建 Thread 子类的实例，也就是创建了线程对象
启动线程，及调用线程的 start()方法

代码实例：

public class MyThread extends Thread {
    public void run() {
        // ...
    }
}
public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}

实现 Runnable 接口创建线程

主要步骤为：

定义 Runnable 接口的实现类，一样要重写 run()方法，这个 run()方法和 Thread()中的 run()方法一样是线程的执行体
创建 Runnable 实现类的实例额，并用这个实例作为 Thread 的 target 来创建 Thread 对象，这个 Thread 对象才是真正的线程对象
通过调用线程对象的 start()房发来启动线程

代码实现：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // ...
    }
}

public static void main(String[] args) {
    MyRunnable instance = new MyRunnable();
    Thread thread = new Thread(instance);
    thread.start();
}

使用 Callable 和 Future 创建线程

注意事项：

和 Runnable 接口不一样，Callable 接口提供了一个 call（）方法作为线程执行体，call()方法比 run()方法功能要强大。

和 Runnable 接口不一样，Callable 接口提供了一个 call（）方法作为线程执行体，call()方法比 run()方法功能要强大。
和 Runnable 接口不一样，Callable 接口提供了一个 call（）方法作为线程执行体，call()方法比 run()方法功能要强大。

call()方法可以有返回值
call()方法可以声明抛出异常

Java5 提供了 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 时间，经过指定时间没有返回抛出 TimeoutException
boolean isDone()：若 Callable 任务完成，返回 True
boolean isCancelled()：如果在 Callable 任务正常完成前被取消，返回 True

主要步骤：

创建 Callable 接口的实现类，并实现 call()方法，然后创建该实现类的实例（从 java8 开始可以直接使用 Lambda 表达式创建 Callable 对象）。
使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了 Callable 对象的 call()方法的返回值
使用 FutureTask 对象作为 Thread 对象的 target 创建并启动线程（因为 FutureTask 实现了 Runnable 接口）
调用 FutureTask 对象的 get()方法来获得子线程执行结束后的返回值

代码实例：

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    // ft.get() 可以获取返回值
    System.out.println(ft.get());
}

// Lambda 表达式方法
public class Test {
　　public static void main(String[] args){
　　　MyThread3 th=new MyThread3();
　　　//使用Lambda表达式创建Callable对象
　　  //使用FutureTask类来包装Callable对象
　　　FutureTask<Integer> future=new FutureTask<Integer>(
　　　　(Callable<Integer>)()->{
　　　　　　return 5;
　　　　}
　　  );
     //实质上还是以Callable对象来创建并启动线程
　　　new Thread(task,"有返回值的线程").start();
　　  try{
        //get()方法会阻塞，直到子线程执行结束才返回
　　　　System.out.println("子线程的返回值："+future.get());
 　　 }catch(Exception e){
　　　　ex.printStackTrace();
　　　}
　　}
}

使用线程池例如用 Executor 框架

1.5 后引入的 Executor 框架的最大优点是把任务的提交和执行解耦。要执行任务的人只需把 Task 描述清楚，然后提交即可。这个 Task 是怎么被执行的，被谁执行的，什么时候执行的，提交的人就不用关心了。具体点讲，提交一个 Callable 对象给 ExecutorService（如最常用的线程池 ThreadPoolExecutor），将得到一个 Future 对象，调用 Future 对象的 get 方法等待执行结果就好了。Executor 框架的内部使用了线程池机制，它在 java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在 Java 5 之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象用 Executor 在构造器中。

Executor 框架包括：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable 等。

Executor 接口中之定义了一个方法 execute（Runnable command），该方法接收一个 Runable 实例，它用来执行一个任务，任务即一个实现了 Runnable 接口的类。ExecutorService 接口继承自 Executor 接口，它提供了更丰富的实现多线程的方法，比如，ExecutorService 提供了关闭自己的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。可以调用 ExecutorService 的 shutdown（）方法来平滑地关闭 ExecutorService，调用该方法后，将导致 ExecutorService 停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭 ExecutorService。因此我们一般用该接口来实现和管理多线程。

ExecutorService 的生命周期包括三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了 shutdown（）方法时，便进入关闭状态，此时意味着 ExecutorService 不再接受新的任务，但它还在执行已经提交了的任务，当素有已经提交了的任务执行完后，便到达终止状态。如果不调用 shutdown（）方法，ExecutorService 会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可。

Executors 提供了一系列工厂方法用于创先线程池，返回的线程池都实现了 ExecutorService 接口。

具体对比图片如下：

Executor 执行 Callable 任务

在 Java 5 之后，任务分两类：一类是实现了 Runnable 接口的类，一类是实现了 Callable 接口的类。两者都可以被 ExecutorService 执行，但是 Runnable 任务没有返回值，而 Callable 任务有返回值。并且 Callable 的 call()方法只能通过 ExecutorService 的 submit(Callable task) 方法来执行，并且返回一个 Future，是表示任务等待完成的 Future。

Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常而 Callable 又返回结果，而且当获取返回结果时可能会抛出异常。Callable 中的 call()方法类似 Runnable 的 run()方法，区别同样是有返回值，后者没有。

当将一个 Callable 的对象传递给 ExecutorService 的 submit 方法，则该 call 方法自动在一个线程上执行，并且会返回执行结果 Future 对象。同样，将 Runnable 的对象传递给 ExecutorService 的 submit 方法，则该 run 方法自动在一个线程上执行，并且会返回执行结果 Future 对象，但是在该 Future 对象上调用 get 方法，将返回 null。

import java.util.ArrayList;   
import java.util.List;   
import java.util.concurrent.*;   
  
public class CallableDemo{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();   
        List<Future<String>> resultList = new ArrayList<Future<String>>();   
  
        //创建10个任务并执行   
        for (int i = 0; i < 10; i++){   
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中   
            Future<String> future = executorService.submit(new TaskWithResult(i));   
            //将任务执行结果存储到List中   
            resultList.add(future);   
        }   
  
        //遍历任务的结果   
        for (Future<String> fs : resultList){   
                try{   
                    while(!fs.isDone);//Future返回如果没有完成，则一直循环等待，直到Future返回完成  
                    System.out.println(fs.get());     //打印各个线程（任务）执行的结果   
                }catch(InterruptedException e){   
                    e.printStackTrace();   
                }catch(ExecutionException e){   
                    e.printStackTrace();   
                }finally{   
                    //启动一次顺序关闭，执行以前提交的任务，但不接受新任务  
                    executorService.shutdown();   
                }   
        }   
    }   
}   
  
  
class TaskWithResult implements Callable<String>{   
    private int id;   
  
    public TaskWithResult(int id){   
        this.id = id;   
    }   
  
    /**  
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法， 
     * 则该方法自动在一个线程上执行 
     */   
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();   
    }   
}

执行结果：

从结果中可以同样可以看出，submit 也是首先选择空闲线程来执行任务，如果没有，才会创建新的线程来执行任务。另外，需要注意：如果 Future 的返回尚未完成，则 get（）方法会阻塞等待，直到 Future 完成返回，可以通过调用 isDone（）方法判断 Future 是否完成了返回。

总结

四种创建线程方法对比

实现 Runnable 和实现 Callable 接口的方式基本相同，不过是后者执行 call()方法有返回值，后者线程执行体 run()方法无返回值，因此可以把这两种方式归为一种这种方式与继承 Thread 类的方法之间的差别如下：

线程只是实现 Runnable 或实现 Callable 接口，还可以继承其他类。
这种方式下，多个线程可以共享一个 target 对象，非常适合多线程处理同一份资源的情形。
但是编程稍微复杂，如果需要访问当前线程，必须调用 Thread.currentThread()方法。
继承 Thread 类的线程类不能再继承其他父类（Java 单继承决定）。
前三种的线程如果创建关闭频繁会消耗系统资源影响性能，而使用线程池可以不用线程的时候放回线程池，用的时候再从线程池取，项目开发中主要使用线程池

线程创建的四种方式详解