Java中创建线程主要有两种核心方式：继承Thread类和实现runnable接口；2. 继承thread类需重写run()方法，通过start()方法启动线程，但受限于java单继承机制；3. 实现runnable接口更灵活，避免单继承限制，实现任务与线程的解耦，便于任务复用和资源共享；4. 更推荐使用实现runnable接口的方式，因其符合“组合优于继承”的设计原则，提升代码复用性和设计弹性；5. 现代java并发编程中应优先使用线程池（executorservice），它通过复用线程降低资源消耗、提高响应速度、统一管理线程、防止资源耗尽，并支持callable和future等高级功能；6. 必须调用start()方法而非直接调用run()，因为start()会触发jvm注册线程、分配资源并交由操作系统调度，从而真正启动新线程并发执行，而直接调用run()仅在当前线程中顺序执行，不创建新线程。
Java中创建和启动线程，主要有两种核心方式：一种是继承
Thread
类，另一种是实现
Runnable
接口。这两种方法各有其适用场景，但本质都是为了让一段代码逻辑能在独立的执行流中运行起来。
解决方案
在Java里，让你的程序具备多任务并行处理的能力，也就是线程，其实并不复杂。我们通常会用到两种主要途径，当然，更现代、更健壮的方案会涉及到线程池。
方法一：继承
Thread
类
立即学习“Java免费学习笔记（深入）”；
这是最直观的方式，你直接创建一个类，让它继承自
java.lang.Thread
，然后重写它的
run()
方法。
run()
方法里放的就是你希望在新线程中执行的代码逻辑。
class MyThread extends Thread { @Override public void run() { System.out.println("我是通过继承Thread类创建的线程，正在执行中..."); try { Thread.sleep(1000); // 模拟耗时操作 } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 重新设置中断状态 System.out.println("MyThread被中断了。"); } System.out.println("MyThread执行完毕。"); } } // 启动方式 public class ThreadCreationDemo { public static void main(String[] args) { MyThread thread1 = new MyThread(); thread1.start(); // 调用start()方法启动线程 System.out.println("主线程继续执行..."); } }
这种方式简单明了，但有个明显的局限：Java是单继承的语言，一旦你继承了
Thread
类，你的类就不能再继承其他任何类了。这在某些设计场景下会显得非常不灵活。
方法二：实现
Runnable
接口
我个人更推荐这种方式，因为它更加符合“面向接口编程”的设计理念，也更灵活。你创建一个类，实现
java.lang.Runnable
接口，同样重写
run()
方法。然后，你需要把这个
Runnable
实例作为参数，传递给
Thread
类的构造器，再通过
Thread
实例来启动。
class MyRunnable implements Runnable { private String taskName; public MyRunnable(String taskName) { this.taskName = taskName; } @Override public void run() { System.out.println(taskName + "：我是通过实现Runnable接口创建的线程，正在执行中..."); try { Thread.sleep(1500); // 模拟耗时操作 } catch (InterruptedException e) { Thread.currentThread().interrupt(); System.out.println(taskName + "被中断了。"); } System.out.println(taskName + "执行完毕。"); } } // 启动方式 public class RunnableCreationDemo { public static void main(String[] args) { MyRunnable runnable1 = new MyRunnable("任务A"); Thread thread2 = new Thread(runnable1); // 将Runnable实例传递给Thread构造器 thread2.start(); MyRunnable runnable2 = new MyRunnable("任务B"); Thread thread3 = new Thread(runnable2); thread3.start(); System.out.println("主线程继续执行，等待其他线程完成..."); } }
实现
Runnable
接口的好处在于，你的业务逻辑类（
MyRunnable
）可以专注于它自己的任务，而不需要关心线程的生命周期管理。同时，它依然可以继承其他类，或者实现其他接口，这大大增强了代码的复用性和设计弹性。
更现代的方式：使用线程池（
ExecutorService
）
在实际项目中，我们很少会直接手动创建和启动大量的
Thread
实例。因为频繁地创建和销毁线程会带来不小的性能开销，而且难以管理。Java并发包（
java.util.concurrent
）提供了强大的线程池机制，通过
ExecutorService
来管理线程。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.Callable; // 示例：使用Callable获取结果 class MyCallable implements Callable<String> { private String name; public MyCallable(String name) { this.name = name; } @Override public String call() throws Exception { System.out.println(name + "：我是通过Callable创建的任务，正在执行..."); Thread.sleep(2000); return name + "任务执行完毕，返回结果。"; } } public class ThreadPoolDemo { public static void main(String[] args) throws Exception { // 创建一个固定大小的线程池，例如2个线程 ExecutorService executor = Executors.newFixedThreadPool(2); // 提交Runnable任务 executor.submit(new MyRunnable("池中任务1")); executor.submit(new MyRunnable("池中任务2")); // 提交Callable任务并获取Future Future<String> futureResult = executor.submit(new MyCallable("池中任务3")); System.out.println("主线程提交任务后继续执行..."); // 获取Callable任务的结果（会阻塞直到任务完成） System.out.println("获取任务3结果：" + futureResult.get()); // 关闭线程池，不再接受新任务，等待已提交任务完成 executor.shutdown(); System.out.println("线程池已关闭。"); } }
线程池是管理和复用线程的利器，它能够有效控制并发线程的数量，避免资源耗尽，并提供更高级的任务提交和结果获取机制（如
Callable
和
Future
）。
Java线程创建后为什么需要调用start()而不是直接调用run()？
这是个非常经典的问题，也是初学者常常会感到困惑的地方。简单来说，如果你直接调用
run()
方法，那么它就和调用一个普通的方法没什么两样，代码会在当前线程（比如主线程）中顺序执行，根本不会创建新的线程。你的程序依然是单线程的。
而
start()
方法则不然。当你调用一个
Thread
对象的
start()
方法时，JVM（Java虚拟机）会做一系列非常关键的事情：
- 线程注册：
start()
方法会向JVM注册这个线程，让JVM知道有一个新的线程要启动了。
- 资源分配： JVM会为这个新线程分配独立的栈空间、程序计数器等线程私有的资源。
- 调度： 最关键的是，
start()
方法会告诉操作系统，请为我这个线程安排CPU时间片，让它有机会独立运行。一旦操作系统调度到这个新线程，JVM就会自动调用它的
run()
方法，并且是在新分配的线程上下文中执行。
所以，
start()
是启动一个新线程的“引爆器”，它触发了JVM和操作系统的协作，从而真正实现了并发执行。而
run()
只是定义了线程要执行的“内容”，它本身并不会创建或启动任何线程。理解这一点，对于掌握java多线程编程至关重要。
Java多线程编程中，选择Runnable接口还是Thread类更合适？
这个问题在实际开发中经常会遇到，我的建议是：优先选择实现
Runnable
接口。
这并非绝对，但从设计原则和工程实践的角度来看，
Runnable
通常是更优的选择，原因如下：
- 单继承限制的规避： Java类只能单继承，如果你继承了
Thread
类，就不能再继承其他任何类了。而实现
Runnable
接口则没有这个限制，你的类依然可以继承其他类，或者实现其他接口，这提供了极大的灵活性，有助于构建更复杂的类层次结构。
- 任务与线程的分离：
Runnable
接口将“任务”（要执行的代码逻辑）与“线程”（执行任务的载体）解耦了。
Runnable
实例代表的是一个可执行的任务，而
Thread
实例才是真正执行这个任务的线程。这种分离使得任务可以被不同的线程执行，或者同一个任务可以被多个线程实例执行（只要创建多个
Thread
对象并传入同一个
Runnable
实例）。这对于任务的复用和管理非常有益。
- 资源共享的便利性： 当多个线程需要共享同一个数据源或资源时，通过实现
Runnable
接口，可以把同一个
Runnable
实例传递给多个
Thread
对象，这样它们就可以轻松访问和操作同一个共享数据。如果继承
Thread
，每个线程都是独立的
Thread
对象，共享数据会稍微复杂一些。
- 更符合面向对象设计： 面向对象设计鼓励“组合优于继承”。将任务逻辑封装在
Runnable
中，然后将
Runnable
对象“组合”到
Thread
对象中，比直接继承
Thread
类更符合这种设计思想。
当然，继承
Thread
类也有其简单的场景，比如当你的类本身就是为了表示一个线程，并且不需要继承其他类时。但总的来说，
Runnable
接口提供了更高的灵活性和更好的设计模式，因此在大多数情况下，它都是更推荐的选择。
java线程池（ExecutorService）在线程管理中有哪些优势？
在现代Java并发编程中，直接手动创建和管理
Thread
对象的情况越来越少，取而代之的是广泛使用线程池，特别是
java.util.concurrent
包下的
ExecutorService
。线程池的优势是多方面的，它极大地简化了并发编程的复杂性，并提升了系统的性能和稳定性。
- 降低资源消耗： 线程的创建和销毁是相对昂贵的操作，涉及到JVM和操作系统的协作。线程池通过复用已存在的线程来执行多个任务，避免了频繁创建和销毁线程的开销。这就好比你有一个工具箱，每次需要用到锤子时，你不需要去重新打造一个，而是直接从工具箱里拿出来用。
- 提高响应速度： 当任务到达时，如果线程池中有空闲线程，任务可以立即被执行，无需等待新线程的创建，从而提高了系统的响应速度。这在处理高并发请求时尤为重要。
- 统一管理和监控： 线程池提供了一套集中的管理机制，可以方便地对线程进行统一的分配、监控和调优。你可以控制池中线程的数量，设置任务队列的容量，甚至自定义拒绝策略，应对系统过载的情况。这比手动管理几十上百个线程要简单得多，也更不容易出错。
- 避免资源耗尽： 如果不使用线程池，任务来了就创建新线程，在高并发场景下，可能会创建出成千上万个线程，这会迅速耗尽系统内存和其他资源，导致系统崩溃。线程池通过限制并发线程的数量，有效地防止了这种资源耗尽的风险。
- 提供更高级的并发工具：
ExecutorService
不仅能执行
Runnable
任务，还能执行
Callable
任务，并通过
Future
对象获取任务的执行结果和处理异常。这对于需要返回结果的异步任务非常有用，极大地扩展了并发编程的能力。
总之，线程池是构建健壮、高性能并发应用的关键组件。它将线程的生命周期管理与业务逻辑解耦，让开发者能够更专注于业务本身的实现，而不是底层线程的细节。
