拼多多1面：Java有哪几种方式创建线程？

发表于 分类于 阅读次数： 本文字数： 3.3k 阅读时长 ≈ 3 分钟

嗨，你好，我是猿java

这篇文章，我们继续分析一道拼多多的面试题：Java有几种方式创建线程？

从应用层面来说，Java 中创建线程的方式主要有四种：

  1. 通过继承 Thread 类
  2. 通过实现 Runnable 接口
  3. 通过实现 Callable 接口配合 Future
  4. 通过使用 Executor 框架。

每种方法都有其独特的特性和适用场景，下面我们将分别讲解4种方式。

继承 Thread 类

通过继承 Thread类来创建线程是 Java中最简单，最基本的方法之一。每一个Thread实例代表着一个单独的执行线程，通过重写 Thread类的run()方法，我们可以定义线程要执行的操作，调用start()方法时，JVM会创建一个新的操作系统线程，并在该线程上调用run()方法。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running using Thread class.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

特点和适用场景：

  • 直接使用继承的方式，代码清晰易懂。
  • 由于 Java 只支持单继承，当你的类需要继承其他类时，继承 Thread 类的方法就不适用了。

实现 Runnable 接口

实现Runnable接口是一种更灵活的创建线程的方式。Runnable接口只定义了一个方法run()，通过实现该接口的类并将其实例传递给Thread对象，我们可以将想要执行的任务分离成单独的类。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running using Runnable interface.");
    }
}

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

特点和适用场景：

  • 适用于希望在多个线程中共享相同任务的场景。
  • 避免了单继承的限制。

实现 Callable 接口配合 Future

Callable 接口与 Runnable 接口类似，但不同的是 Callable 可以返回结果或抛出异常。通常与Future和ExecutorService结合使用，ExecutorService管理线程的生命周期，Future对象可以获取线程的执行结果或状态。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Thread is running using Callable interface.";
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());

        try {
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

特点和适用场景：

  • 适合需要任务返回结果或监控任务状态的场景。
  • 相比 Runnable，Callable 可以抛出检查型异常。

使用Executor框架（线程池）

Executor 框架是 Java 并发编程的基础结构，分离了任务的提交和任务的执行。通过 ExecutorService 提交任务，可以通过复用线程来提高性能，降低系统资源的开销，然后框架负责管理线程池、任务调度等。

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        Runnable task = () -> {
            System.out.println("Thread is running using Executor framework.");
        };

        for (int i = 0; i < 5; i++) {
            executor.submit(task);
        }

        executor.shutdown();
    }
}

特点和适用场景：

  • 非常适合需要多个线程或线程池来管理任务的复杂场景。
  • 提高应用程序的可伸缩性和资源使用率。
  • 管理线程池的生命周期和任务调度，降低难度。

如何选择？

  1. 代码重用性与继承关系：继承 Thread 类的方式由于 Java 的单继承特性可能不够灵活，尤其是在类需要从其他类继承时。使用 Runnable 或 Callable 会更适合此类场景。

  2. 返回结果和异常处理：如果任务需要返回结果或需要处理异常，Callable 配合 Future 是更好的选择。相比之下，Runnable 不支持返回任务执行的结果。

  3. 任务管理：对于任务的管理和调度，尤其是涉及到线程的生命周期管理时，Executor 框架提供了更好的抽象和工具支持。框架本身负责优化线程的创建与销毁。

  4. 易用性：继承 Thread 或实现 Runnable 都是较为简单和直观的方法，适合初学者或较简单的任务。

  5. 性能与可伸缩性：Executor 框架不仅能提供方便的任务执行接口，还能为复杂应用的性能优化提供支持，如根据服务器资源动态调整线程池大小。

总结

线程是 Java的最小执行单元，Java如何创建线程是个古老又重要的话题和面试题，这篇文章我们又啰嗦了一遍。作为开发人员，选择哪种方式创建线程，需要结合应用的具体需求和特点，但是，无论选择哪种方式，理解每种方法的原理，特点与适用场景在实际开发中都至关重要。

学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing