Java 实现多线程的四种方式，一文讲透！

大家好，欢迎来到IT知识分享网。

在互联网大厂的业务场景中，后端服务面临着海量的用户请求。以电商平台为例，在双 11、618 等大型促销活动期间，抢购活动瞬间可能会有几万甚至几十万的订单请求涌入。如果采用单线程处理，服务器只能按照请求的先后顺序，一个一个地处理订单，不仅效率低下，还可能因为长时间的等待导致用户失去耐心，放弃购买。

再比如社交平台，消息推送功能需要同时处理众多用户的消息分发。单线程处理时，当有大量新消息产生，推送速度极慢，用户不能及时收到消息通知，严重影响用户体验。而多线程能够让程序同时执行多个任务，充分利用 CPU 资源，就像为系统配备了多个勤劳的 “小助手”，它们可以同时处理不同的请求，大大提升系统的处理能力和响应速度。据统计，合理使用多线程技术，能让系统的处理性能提升 3 – 5 倍，这就是多线程在后端开发中至关重要的原因。

四种实现方式详解，掌握多线程核心技术

继承 Thread 类：多线程实现的基础入门

继承 Thread 类实现多线程是最基础的方式之一，它就像是多线程学习的 “敲门砖”。

步骤一：定义线程类

创建一个类继承自 Thread 类，并重写 run 方法，run 方法中的代码就是线程执行的内容。

// 定义一个继承自Thread的线程类MyThread public class MyThread extends Thread { @Override public void run() { System.out.println("这是通过继承Thread类实现的多线程"); } }

在这个示例中，MyThread 类继承了 Thread 类，并重写了 run 方法，当该线程启动后，就会执行 run 方法中的代码，打印出相应的信息。

步骤二：启动线程

在 main 方法或者其他合适的地方创建线程对象，然后调用 start 方法来启动线程。这里需要特别注意，不能直接调用 run 方法来启动线程，如果直接调用 run 方法，就相当于在当前线程中执行 run 方法中的代码，而不是开启一个新的线程。

public class Main { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); // 启动线程 } }

应用场景

这种方式适用于一些较为简单，且与线程本身关联紧密的任务。比如在游戏开发中，创建一个单独的线程用于处理游戏角色的动画效果更新，每个角色对应一个继承 Thread 类的线程，方便对角色动画线程进行单独管理和控制 。

实现 Runnable 接口：灵活的多线程实现方案

实现 Runnable 接口也是常用的实现多线程的方式，相比继承 Thread 类，它更具灵活性，就像一把 “万能钥匙”，可以适配各种复杂的场景。

步骤一：创建实现 Runnable 接口的类

创建一个类实现 Runnable 接口，实现 run 方法，这个 run 方法包含了线程要执行的任务。

// 创建实现Runnable接口的类MyRunnable public class MyRunnable implements Runnable { @Override public void run() { System.out.println("这是通过实现Runnable接口实现的多线程"); } }

步骤二：创建线程并启动

首先创建 Runnable 对象，然后将其作为参数传递给 Thread 对象的构造函数，最后调用 Thread 对象的 start 方法来启动线程。实现 Runnable 接口的优势是更灵活，因为一个类可以实现多个接口，避免了单继承的限制。例如，如果一个类已经继承了其他类，还想实现多线程功能，就可以使用实现 Runnable 接口的方式。而且 Runnable 对象可以被多个线程共享，方便在多个线程中执行相同的任务。

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

实际案例

在一个电商的库存管理系统中，有多个商品的库存需要实时更新。可以创建一个实现 Runnable 接口的类来处理库存更新任务，然后创建多个线程，每个线程处理一种商品的库存更新，实现了任务的并行处理，提高了库存更新的效率。同时，由于 Runnable 对象可共享，也方便对库存更新逻辑进行统一管理和维护。

使用 Callable 和 Future：带返回值的多线程实现

使用 Callable 和 Future 实现多线程的特点是线程执行任务后可以有返回值，这就好比你派出去的 “使者”，完成任务后还能给你带回重要的 “情报”。

步骤一：创建实现 Callable 接口的类

创建一个类实现 Callable 接口，实现 call 方法，call 方法中包含线程要执行的任务，并且可以有返回值。

import java.util.concurrent.Callable; // 创建实现Callable接口的类MyCallable public class MyCallable implements Callable<String> { @Override public String call() throws Exception { return "这是通过Callable和Future实现的多线程，有返回值哦"; } }

在这个例子中，MyCallable 类实现了 Callable 接口，call 方法执行完成后会返回一个字符串。

步骤二：通过 ExecutorService 提交 Callable 任务

ExecutorService 可以通过 Executors 工厂类来创建。在这里，submit 方法提交 Callable 任务并返回一个 Future 对象，通过 Future 对象的 get 方法可以获取 Callable 任务的返回值。shutdown 方法用于关闭 ExecutorService。

import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class Main { public static void main(String[] args) throws ExecutionException, InterruptedException { ExecutorService executorService = Executors.newSingleThreadExecutor(); Future<String> future = executorService.submit(new MyCallable()); System.out.println(future.get()); executorService.shutdown(); } }

技术拓展

在实际开发中，可能会遇到任务执行时间较长的情况，这时可以使用 Future 的 isDone () 方法来判断任务是否完成，避免主线程一直阻塞等待。同时，如果任务执行过程中出现异常，在调用 future.get () 方法获取返回值时，会抛出 ExecutionException 异常，可以通过 try – catch 块进行捕获和处理 。

线程池（ExecutorService）：高效管理多线程

线程池在实际开发中应用广泛，它能有效管理和复用线程，避免频繁创建和销毁线程带来的开销，就像一个 “高效的员工管理中心”，合理调配员工（线程），让工作（任务）高效完成。

步骤一：创建线程池

可以使用 Executors 工厂类创建不同类型的线程池，如 newFixedThreadPool（固定大小线程池）、newCachedThreadPool（可缓存线程池）、newSingleThreadExecutor（单线程线程池）等。

• newFixedThreadPool：创建固定大小的线程池，线程池中的线程数量固定，当有任务提交时，如果有空闲线程则立即执行，若无空闲线程则将任务放入等待队列，直到有线程空闲。适用于处理负载相对稳定，任务量可预估的场景，比如数据库的批量数据查询操作。
• newCachedThreadPool：可缓存线程池，线程数量不固定，当有新任务提交时，如果有空闲线程则复用，若无则创建新线程，线程空闲一段时间（默认 60 秒）后会被回收。适用于执行大量的短期异步任务，例如处理大量的用户请求日志记录。
• newSingleThreadExecutor：单线程线程池，只有一个工作线程，所有任务按照顺序依次执行，保证任务的顺序性。适用于需要保证任务顺序执行，或者资源需要串行访问的场景，比如对全局唯一资源的读写操作。

步骤二：提交任务

可以使用 execute 方法提交 Runnable 任务，或者使用 submit 方法提交 Callable 任务到线程池。

步骤三：关闭线程池

当任务执行完毕后，需要关闭线程池。可以使用 shutdown 方法来正常关闭线程池，它会等待所有已提交的任务执行完毕后再关闭。如果想要立即关闭线程池，可以使用 shutdownNow 方法，但这种方式可能会导致正在执行的任务被中断。

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Main { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(5); // 创建固定大小为5的线程池 for (int i = 0; i < 10; i++) { executorService.execute(() -> { System.out.println(Thread.currentThread().getName() + "正在执行任务"); }); } executorService.shutdown(); } }

性能优势

线程池通过复用线程，减少了线程创建和销毁的开销。经测试，在处理大量短时间任务时，使用线程池比每次创建新线程执行任务，性能提升可达 30% – 50%，大大提高了系统的资源利用率和执行效率。

总结

通过以上对 Java 实现多线程四种方式的详细介绍，相信你对多线程有了更深入的理解。从基础的继承 Thread 类，到灵活的实现 Runnable 接口；从能获取返回值的 Callable 和 Future，再到高效管理线程的线程池，每一种方式都有其独特的应用场景和优势。

在实际的互联网大厂后端开发工作中，希望你能根据不同的业务场景，灵活运用这些多线程方式，优化程序性能。比如在高并发的订单处理场景中，使用线程池快速处理大量订单；在需要获取任务执行结果的数据分析场景下，选择 Callable 和 Future。

如果你在使用过程中有任何疑问，或者有更好的实践经验，欢迎在评论区分享交流，咱们一起在后端开发的道路上不断前行，用多线程技术打造更高效、更强大的后端系统！