Java多线程创建与启动方法全解析

还在为Java多线程的创建和启动而困惑吗？本文将深入剖析两种核心方法：实现Runnable接口和继承Thread类。推荐优先选择Runnable接口，它能解耦任务逻辑与线程，更符合单一职责原则，并避免Java单继承的限制，利于任务复用和线程池管理。启动线程的关键在于调用`start()`方法，而非直接调用`run()`方法，前者由JVM创建新线程并异步执行，后者仅为同步执行。文章还将详细介绍线程的六种生命周期状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED，助你全面理解和调试多线程程序，轻松掌握Java并发编程的核心要点。

Java中创建和启动多线程程序的核心方法有两种：1. 实现Runnable接口，将任务逻辑与线程解耦，便于任务复用和线程池管理；2. 继承Thread类，直接定义线程行为，但受限于Java单继承机制。应优先选择实现Runnable接口，因其更符合单一职责原则且灵活性更高。启动线程必须调用start()方法，它会由JVM创建新线程并异步执行run()中的任务；若直接调用run()，则仅作为普通方法在当前线程同步执行，无法实现并发。线程生命周期包括五种状态：NEW（新建）、RUNNABLE（可运行）、BLOCKED（阻塞）、WAITING（无限等待）、TIMED_WAITING（限时等待）和TERMINATED（终止），理解这些状态有助于分析和调试多线程程序的执行行为。

Java中创建和启动多线程程序，核心在于定义好线程要执行的任务，然后通过Thread类来调度和启动这个任务。这通常有两种基本方式：要么让你的任务类实现Runnable接口，要么直接继承Thread类。无论哪种，最终都是通过调用Thread实例的start()方法来真正启动一个新线程。

解决方案

创建和启动多线程程序，我们通常会选择以下两种路径：

1. 实现 Runnable 接口

这是更推荐的方式，因为它将任务（Runnable）与线程（Thread）本身解耦。一个类可以实现多个接口，但只能继承一个类，所以用Runnable能更好地规避Java的单继承限制。

• 定义任务： 创建一个类实现Runnable接口，并重写其run()方法。run()方法里就是你希望新线程执行的代码逻辑。

  class MyRunnableTask implements Runnable {
      private String taskName;
  
      public MyRunnableTask(String name) {
          this.taskName = name;
      }
  
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName() + " 正在执行任务: " + taskName);
          try {
              // 模拟任务执行耗时
              Thread.sleep(100 + (long)(Math.random() * 500));
          } catch (InterruptedException e) {
              System.out.println(taskName + " 被中断了！");
              Thread.currentThread().interrupt(); // 重新设置中断状态
          }
          System.out.println(Thread.currentThread().getName() + " 完成了任务: " + taskName);
      }
  }

• 创建并启动线程： 实例化MyRunnableTask，然后将其作为参数传递给Thread类的构造器，最后调用Thread对象的start()方法。

  public class ThreadWithRunnableDemo {
      public static void main(String[] args) {
          System.out.println("主线程开始...");
  
          // 创建Runnable任务实例
          Runnable task1 = new MyRunnableTask("下载文件A");
          Runnable task2 = new MyRunnableTask("处理数据B");
          Runnable task3 = new MyRunnableTask("发送邮件C");
  
          // 创建Thread实例并传入Runnable任务
          Thread thread1 = new Thread(task1, "工作线程-1");
          Thread thread2 = new Thread(task2, "工作线程-2");
          Thread thread3 = new Thread(task3, "工作线程-3");
  
          // 启动线程
          thread1.start();
          thread2.start();
          thread3.start();
  
          System.out.println("主线程继续执行，不再等待子线程...");
          // 主线程可以继续做自己的事情
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("主线程结束。");
      }
  }

2. 继承 Thread 类

这种方式更直接，但由于Java的单继承特性，你的任务类就不能再继承其他类了。

• 定义任务： 创建一个类继承Thread类，并重写其run()方法。

  class MyThread extends Thread {
      private String taskName;
  
      public MyThread(String name) {
          super(name); // 调用父类构造器设置线程名
          this.taskName = name;
      }
  
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName() + " 正在执行任务: " + taskName);
          try {
              // 模拟任务执行耗时
              Thread.sleep(50 + (long)(Math.random() * 300));
          } catch (InterruptedException e) {
              System.out.println(taskName + " 被中断了！");
              Thread.currentThread().interrupt();
          }
          System.out.println(Thread.currentThread().getName() + " 完成了任务: " + taskName);
      }
  }

• 创建并启动线程： 直接实例化MyThread类，然后调用其start()方法。

  public class ThreadExtendsDemo {
      public static void main(String[] args) {
          System.out.println("主线程开始...");
  
          // 创建MyThread实例
          MyThread threadA = new MyThread("独立线程-A");
          MyThread threadB = new MyThread("独立线程-B");
  
          // 启动线程
          threadA.start();
          threadB.start();
  
          System.out.println("主线程继续执行...");
          try {
              Thread.sleep(800);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println("主线程结束。");
      }
  }

Java多线程中，Runnable和Thread有什么区别，我该如何选择？

这确实是个老生常谈的问题，但对于初学者来说，弄清楚它至关重要。简单来说，Runnable是一个接口，它定义了“要执行什么任务”，而Thread是一个类，它定义了“如何执行这个任务”。

Runnable的本质，是把任务的逻辑和线程的控制分开了。当你实现Runnable时，你只是告诉Java虚拟机：“嘿，这是我想让某个线程去跑的代码。”至于哪个线程来跑，怎么调度，那都是Thread类的事情。这种分离带来的好处是显而易见的：你的任务类可以专注于业务逻辑，不用关心线程的生命周期管理。更重要的是，Java是单继承的语言，如果你已经继承了某个业务类，就不能再继承Thread了。而实现接口则没有这个限制，你可以实现多个接口，包括Runnable。这让Runnable在实际项目中更具灵活性和复用性，特别是在线程池的场景下，你通常提交的就是Runnable任务。

相比之下，继承Thread类显得更直接，但也有其局限性。当你继承Thread时，你的类“就是”一个线程。这意味着你的业务逻辑和线程行为紧密耦合在一起。如果你想让多个线程执行同一个任务，你可能需要创建多个Thread子类的实例，每个实例都包含一份任务逻辑。这在资源共享上可能会带来一些不便。

所以，我的建议是：

• 优先使用 Runnable。 绝大多数情况下，你只需要定义一个可执行的任务，而不是去定义一个全新的线程类型。它更符合面向对象设计原则中的“单一职责原则”，任务就是任务，线程就是线程。
• 只有当你需要扩展 Thread 类的行为时，才考虑继承 Thread。 比如，你需要自定义线程的一些特定行为，或者为线程添加一些特有的属性和方法，而不仅仅是执行一个任务。但这样的场景相对较少。

从我的个人经验来看，当你开始接触更高级的并发工具，比如ExecutorService（线程池），你会发现它们都是围绕Runnable（或Callable）设计的。这进一步印证了Runnable作为任务定义者的核心地位。

启动线程时，为什么是调用start()而不是直接调用run()？

这是一个非常常见的误区，也是初学者经常会犯的错误。直观上，我们看到run()方法里是线程要执行的代码，就觉得直接调用它就行了。但实际上，start()和run()的调用效果是天壤之别。

当你调用一个Thread对象的start()方法时，JVM会做一系列底层操作：

1. 分配系统资源： JVM会向操作系统申请创建一个新的线程。操作系统会为这个新线程分配独立的栈空间、程序计数器等资源。
2. 线程注册： 这个新创建的线程会被注册到JVM的线程调度器中，等待被CPU调度执行。
3. 异步执行： start()方法会立即返回，而run()方法里的代码则会在这个新创建的线程中异步、并发地执行。这意味着调用start()的主线程（或者说，当前线程）不会被阻塞，它可以继续执行自己的代码。

而如果你直接调用run()方法呢？

1. 普通方法调用： run()方法就只是一个普通的Java方法调用。
2. 同步执行： 它的代码会在当前线程中同步执行。也就是说，哪个线程调用了run()，run()方法里的代码就在哪个线程里执行。它不会创建任何新的线程，也不会有任何并发的效果。调用run()的线程会一直等到run()方法执行完毕，才继续执行它后面的代码。

想象一下，你有一个快递员（线程），他需要去送包裹（任务）。start()就像是快递公司给你安排了一个新的快递员，他会独立地去送包裹，你可以在家里继续做自己的事情。而直接调用run()，就相当于你自己拿起包裹，亲自去送了，你得等到送完才能回来做别的事。

所以，要真正实现多线程和并发，start()是唯一的正确入口。它才是启动一个全新执行流的关键。

Java多线程程序运行中，有哪些常见的线程状态和生命周期？

理解线程的生命周期和状态对于调试和优化多线程程序至关重要。一个线程从诞生到消亡，会经历不同的状态。Java的Thread.State枚举定义了这些状态，它们分别是：

1. NEW (新建):

   • 当你使用new Thread()创建了一个线程对象，但还没有调用它的start()方法时，线程就处于这个状态。
   • 它只是一个普通的Java对象，还没有被操作系统识别为线程。

2. RUNNABLE (可运行/运行中):

   • 当你调用了线程的start()方法后，线程就进入了RUNNABLE状态。
   • 这个状态表示线程可能正在运行（获得了CPU时间片），或者它已经准备好运行（正在等待CPU调度）。
   • Java的RUNNABLE状态包含了操作系统层面的“运行中”和“就绪”两种状态。

3. BLOCKED (阻塞):

   • 当一个线程试图获取一个对象的内部锁（也称为监视器锁，synchronized关键字）但该锁已经被其他线程持有，它就会进入BLOCKED状态。
   • 线程会一直等待，直到它能够获取到所需的锁。

4. WAITING (等待):

   • 线程进入无限期等待状态，直到另一个线程执行了特定的操作来唤醒它。
   • 常见进入WAITING状态的方法有：
     • Object.wait()：当一个线程在某个对象上调用wait()方法时，它会释放该对象的锁并进入WAITING状态。
     • Thread.join()：当一个线程调用另一个线程的join()方法时，它会等待被join的线程执行完毕。
     • LockSupport.park()：JUC（java.util.concurrent）包中的低级别同步原语。

5. TIMED_WAITING (有时限等待):

   • 线程在指定的时间内等待另一个线程执行特定操作，或者等待指定的时间过去。
   • 与WAITING类似，但有时间限制。
   • 常见进入TIMED_WAITING状态的方法有：
     • Thread.sleep(long millis)：线程休眠指定时间。
     • Object.wait(long timeout)：在指定时间内等待对象锁。
     • Thread.join(long millis)：在指定时间内等待被join的线程。
     • LockSupport.parkNanos(Object blocker, long nanos) / LockSupport.parkUntil(long deadline)。

6. TERMINATED (终止):

   • 线程的run()方法执行完毕，或者因异常而退出，线程就进入TERMINATED状态。
   • 一旦线程进入TERMINATED状态，它就不能再被重新启动了。如果你尝试再次调用start()，会抛出IllegalThreadStateException。

这些状态构成了线程的完整生命周期。理解它们，能帮助我们更好地分析线程的运行情况，比如为什么某个线程“卡住”了（可能是BLOCKED或WAITING），或者为什么没有并发效果（可能start()没被正确调用，run()直接执行了）。在实际开发中，使用JMX工具或者JDK自带的jstack命令，可以查看JVM中所有线程的当前状态，这对于诊断并发问题非常有帮助。

文中关于thread,Java多线程,线程生命周期,runnable,start()的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Java多线程创建与启动方法全解析》文章吧，也可关注golang学习网公众号了解相关技术文章。