在 Java 中，线程的创立办法有 7 种，分为以下 3 大类：

  1. 继承 Thread 类的形式，它有 2 种实现办法。
  2. 实现 Runnable 接口的形式，它有 3 种实现办法。
  3. 实现 Callable 接口的形式，它有 2 种实现办法。

接下来咱们一个一个来看。

1.继承Thread类

继承 Thread 类并重写 run 办法，是最晚期创立线程的办法，它的实现办法有以下两种：

  1. 创立一个一般的类，继承 Thread 类，并重写 run 办法。
  2. 应用匿名外部类的形式继承并重写 run 办法。

具体实现如下。

1.1 一般类继承Thread

创立一个一般类，继承 Thread 并重写 run 办法，其中 run 办法中的代码是线程具体要执行的业务代码，实现如下：

// 自定义一个类继承 Thread 并重写 run 办法class MyThread extends Thread {    @Override    public void run() {        // 增加业务办法...    }}// 创立线程并执行public class ThreadExample {    public static void main(String[] args) {        // 创立线程        Thread thread = new MyThread();        // 启动线程        thread.start();    }}

1.2 匿名外部类

下面的写法有点繁琐，咱们还能够应用以下匿名类的形式来实现：

// 匿名形式创立线程Thread t1 = new Thread() {    @Override    public void run() {        // 增加业务办法...    }};// 启动线程t1.start();

1.3 毛病剖析

继承 Thread 类的实现办法有一个显著的毛病，Java 语言是单继承的，所以如果继承了 Thread 类，那就不能再继承其余类了。

2.实现Runnable接口

在 Java 语言中，尽管不能多继承，但能够实现多个接口。接下来是实现 Runnable 接口的 3 种办法：

  1. 创立一个一般类实现 Runnable 接口，并重写 run 办法。
  2. 应用匿名形式创立 Runnable 实现类，并重写 run 办法。

  3. 应用 Lambda 形式创立匿名 Runnable 实现类（JDK 8+）。

    2.1 一般类实现Runnable

    // 定义一个一般类实现 Runnable 接口class MyRunnable implements Runnable { @Override public void run() {     // 增加业务办法... }}// 线程创立public static void main(String[] args) { // 创立一个 Runnable 实现类 MyRunnable myRunnable = new MyRunnable(); // 创立线程 Thread thread = new Thread(myRunnable); // 启动线程 thread.start();}

    2.2 匿名Runnable实现类

    // 匿名 Runnable 实现类Thread t2 = new Thread(new Runnable() { @Override public void run() {     // 增加业务办法... }});// 启动线程t2.start();

    2.3 Lambda创立Runnable

    在 JDK 8 之后（蕴含 JDK 8），咱们能够应用 Lambda 表达式来创立线程，如下代码所示：

    // 应用 Lambda 匿名 Runnable 形式Thread t3 = new Thread(() -> { // 增加业务办法...});// 启动线程t3.start();

    从上述代码能够看出，如果是 JDK 1.8 以上的程序，在不要求取得线程执行后果的状况下，举荐应用 Lambda 的形式来创立线程，因为它的写法足够简洁。

    2.4 毛病剖析

    以上创立线程的办法，都有一个通用的问题：那就是不能取得线程的执行后果。

    3.应用Callable接口

    JDK 1.5 中推出的 Callable 接口，解决了之前不能取得线程执行后果的难堪，它的实现办法有以下两种：

  4. 创立一个一般类实现 Callable 接口，并重写 call 办法。

  5. 应用匿名外部类创立 Callable 的实现类，并重写 call 办法。

    3.1 一般类实现Callable

    // 定义一般实现 Callable 接口，返回一个 Integer 类型的后果（当然也能够返回其余类型的后果）class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception {     // 业务实现代码...     return 0; }}// 创立线程public static void main(String[] args) throws ExecutionException, InterruptedException { // 创立 Callable 一般类 MyCallable callable = new MyCallable(); // 应用 FutureTask 用于获取线程执行后果 FutureTask<Integer> futureTask = new FutureTask<>(callable); // 创立线程 Thread thread = new Thread(futureTask); // 启动线程 thread.start(); // 失去线程执行的后果 int result = futureTask.get();}

    以上代码应用 FutureTask + Callable 的形式获取线程的执行后果，它能够承受任何类型的返回值，咱们只须要在创立 Callable 实现类的时候，定义返回的数据类型即可。

    3.2 匿名Callable实现类

    // FutureTask 用于获取线程执行后果FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() { @Override public Integer call() throws Exception {     // 业务代码...     return 0; }});// 创立线程Thread thread = new Thread(futureTask);// 启动线程thread.start();// 失去线程执行的后果int result = futureTask.get();

    总结

    在 Java 语言中，创立线程有 3 大类实现形式、7 种实现办法，如果是 JDK 1.8 以上版本，在不须要取得线程执行后果的状况下，举荐应用 Lambda 形式来创立线程，因为它的写法足够简洁；如果想要获取线程执行后果，可应用 FutureTask + Callable 的形式来实现。

是非审之于己，毁誉听之于人，得失安之于数。

公众号：Java面试真题解析

面试合集：https://gitee.com/mydb/interview