Java线程创建与启动的实用方法

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.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 {
    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 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虚拟机）会做一系列非常关键的事情：

1. 线程注册： start()方法会向JVM注册这个线程，让JVM知道有一个新的线程要启动了。
2. 资源分配： JVM会为这个新线程分配独立的栈空间、程序计数器等线程私有的资源。
3. 调度： 最关键的是，start()方法会告诉操作系统，请为我这个线程安排CPU时间片，让它有机会独立运行。一旦操作系统调度到这个新线程，JVM就会自动调用它的run()方法，并且是在新分配的线程上下文中执行。

所以，start()是启动一个新线程的“引爆器”，它触发了JVM和操作系统的协作，从而真正实现了并发执行。而run()只是定义了线程要执行的“内容”，它本身并不会创建或启动任何线程。理解这一点，对于掌握Java多线程编程至关重要。

Java多线程编程中，选择Runnable接口还是Thread类更合适？

这个问题在实际开发中经常会遇到，我的建议是：优先选择实现Runnable接口。

这并非绝对，但从设计原则和工程实践的角度来看，Runnable通常是更优的选择，原因如下：

1. 单继承限制的规避： Java类只能单继承，如果你继承了Thread类，就不能再继承其他任何类了。而实现Runnable接口则没有这个限制，你的类依然可以继承其他类，或者实现其他接口，这提供了极大的灵活性，有助于构建更复杂的类层次结构。
2. 任务与线程的分离： Runnable接口将“任务”（要执行的代码逻辑）与“线程”（执行任务的载体）解耦了。Runnable实例代表的是一个可执行的任务，而Thread实例才是真正执行这个任务的线程。这种分离使得任务可以被不同的线程执行，或者同一个任务可以被多个线程实例执行（只要创建多个Thread对象并传入同一个Runnable实例）。这对于任务的复用和管理非常有益。
3. 资源共享的便利性： 当多个线程需要共享同一个数据源或资源时，通过实现Runnable接口，可以把同一个Runnable实例传递给多个Thread对象，这样它们就可以轻松访问和操作同一个共享数据。如果继承Thread，每个线程都是独立的Thread对象，共享数据会稍微复杂一些。
4. 更符合面向对象设计： 面向对象设计鼓励“组合优于继承”。将任务逻辑封装在Runnable中，然后将Runnable对象“组合”到Thread对象中，比直接继承Thread类更符合这种设计思想。

当然，继承Thread类也有其简单的场景，比如当你的类本身就是为了表示一个线程，并且不需要继承其他类时。但总的来说，Runnable接口提供了更高的灵活性和更好的设计模式，因此在大多数情况下，它都是更推荐的选择。

Java线程池（ExecutorService）在线程管理中有哪些优势？

在现代Java并发编程中，直接手动创建和管理Thread对象的情况越来越少，取而代之的是广泛使用线程池，特别是java.util.concurrent包下的ExecutorService。线程池的优势是多方面的，它极大地简化了并发编程的复杂性，并提升了系统的性能和稳定性。

1. 降低资源消耗： 线程的创建和销毁是相对昂贵的操作，涉及到JVM和操作系统的协作。线程池通过复用已存在的线程来执行多个任务，避免了频繁创建和销毁线程的开销。这就好比你有一个工具箱，每次需要用到锤子时，你不需要去重新打造一个，而是直接从工具箱里拿出来用。
2. 提高响应速度： 当任务到达时，如果线程池中有空闲线程，任务可以立即被执行，无需等待新线程的创建，从而提高了系统的响应速度。这在处理高并发请求时尤为重要。
3. 统一管理和监控： 线程池提供了一套集中的管理机制，可以方便地对线程进行统一的分配、监控和调优。你可以控制池中线程的数量，设置任务队列的容量，甚至自定义拒绝策略，应对系统过载的情况。这比手动管理几十上百个线程要简单得多，也更不容易出错。
4. 避免资源耗尽： 如果不使用线程池，任务来了就创建新线程，在高并发场景下，可能会创建出成千上万个线程，这会迅速耗尽系统内存和其他资源，导致系统崩溃。线程池通过限制并发线程的数量，有效地防止了这种资源耗尽的风险。
5. 提供更高级的并发工具： ExecutorService不仅能执行Runnable任务，还能执行Callable任务，并通过Future对象获取任务的执行结果和处理异常。这对于需要返回结果的异步任务非常有用，极大地扩展了并发编程的能力。

总之，线程池是构建健壮、高性能并发应用的关键组件。它将线程的生命周期管理与业务逻辑解耦，让开发者能够更专注于业务本身的实现，而不是底层线程的细节。