package ajiayou.index0711.demo02; import java.util.Random; /*注释补充：步骤1：定义线程辅助类，实现Runnable接口*/ public class Match1 implements Runnable{ /*注释补充：Match1是线程辅助类*/ /*注释补充：implements接口*/ /*注释补充：步骤2：重写run()方法，定义线程行为*/ //这个方法就是线程的方法,以后我们操作都在这个里面写 @Override public void run() { Random r = new Random(); //这里是随机数 int speed = r.nextInt(100); for(int i = 1; i<=100; i++) { //睡眠100毫秒 try { Thread.sleep(30); } catch (InterruptedException e) { throw new RuntimeException(e); } //Thread.currentThread().getName() //获得当前线程的名称 System.out.println(Thread.currentThread().getName() + "已前进" + (i * speed) + "米(" + speed + "米/秒)"); } } } /* 注释补充：创建一个线程 Java 提供了三种创建线程的方法： 1.通过继承 Thread 类本身； 2.通过实现 Runnable 接口； 创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。 为了实现 Runnable，一个类只需要执行一个方法调用 run()，声明如下： public void run() 你可以重写该方法，重要的是理解的 run() 可以调用其他方法，使用其他类，并声明变量，就像主线程一样。 在创建一个实现 Runnable 接口的类之后，你可以在类中实例化一个线程对象。 Thread 定义了几个构造方法，下面的这个是我们经常使用的： Thread(Runnable threadOb,String threadName); 这里，threadOb 是一个实现 Runnable 接口的类的实例，并且 threadName 指定新线程的名字。 新线程创建之后，你调用它的 start() 方法它才会运行。 void start(); 3.通过 Callable 和 Future 创建线程。*/

<think>我们正在讨论Java中通过实现Runnable接口来创建线程的方法。根据引用内容，实现Runnable接口创建线程的步骤是： 1. 创建一个类实现Runnable接口。 2. 重写run()方法，在run()方法中编写线程要执行的代码。 3. 创建该类的实例。 4. 将此实例作为参数传递给Thread类的构造器，创建Thread对象。 5. 调用Thread对象的start()方法启动线程。 此外，引用中还提到了使用Lambda表达式简化实现（适用于函数式接口，Runnable只有一个抽象方法run()）以及静态代理模式（Thread类作为代理，执行我们传入的Runnable实现类的run方法）。 下面我将按照步骤详细说明，并给出示例代码。 ### 步骤详解： 1. **实现Runnable接口**：创建一个类（比如`MyRunnable`）并实现`java.lang.Runnable`接口。 2. **重写run方法**：在`MyRunnable`类中，必须实现`run()`方法，该方法将作为线程的执行体。 3. **创建Runnable实例**：在main方法中，创建`MyRunnable`类的对象。 4. **创建Thread对象**：将`MyRunnable`对象作为参数传递给`Thread`类的构造器，这样`Thread`对象就知道启动线程时要执行哪个`run`方法。 5. **启动线程**：调用`Thread`对象的`start()`方法，这会启动一个新的线程，并在新线程中执行`run()`方法。 ### 示例代码： ```java // 步骤1：实现Runnable接口 public class MyRunnable implements Runnable { // 步骤2：重写run方法 @Override public void run() { // 线程执行的任务 for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName() + " 执行: " + i); } } public static void main(String[] args) { // 步骤3：创建Runnable实例 MyRunnable myRunnable = new MyRunnable(); // 步骤4：创建Thread对象，并将myRunnable作为参数传递 Thread thread1 = new Thread(myRunnable, "线程1"); Thread thread2 = new Thread(myRunnable, "线程2"); // 步骤5：启动线程 thread1.start(); thread2.start(); // 主线程继续执行 for (int i = 0; i < 5; i++) { System.out.println("主线程: " + i); } } } ``` ### 代码解释： - 我们创建了一个`MyRunnable`类实现`Runnable`接口，并重写了`run`方法，其中循环打印10次当前线程名和计数。 - 在main方法中，创建了一个`MyRunnable`对象`myRunnable`。 - 创建两个Thread对象（`thread1`和`thread2`），它们共享同一个`myRunnable`实例。这意味着两个线程将执行同一个`run`方法中的代码，但每个线程有自己的执行路径。 - 启动两个线程，同时主线程也继续执行自己的循环（打印5次）。 ### 运行结果分析： 运行程序，你会看到控制台交替打印三个线程（主线程、线程1、线程2）的输出。由于线程调度的不确定性，每次运行输出的顺序可能不同。 ### 使用Lambda表达式简化： 由于`Runnable`是一个函数式接口（只有一个抽象方法），我们可以使用Lambda表达式简化代码，无需显式创建实现类： ```java public class RunnableWithLambda { public static void main(String[] args) { // 使用Lambda表达式实现Runnable接口 Runnable runnable = () -> { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; // 创建线程并启动 Thread thread = new Thread(runnable, "Lambda线程"); thread.start(); // 更简洁的写法：直接将Lambda表达式传入Thread构造器 new Thread(() -> { for (int i = 0; i < 10; i++) { System.out.println("直接Lambda线程: " + i); } }).start(); } } ``` ### 优点： 1. **避免单继承局限**：Java不支持多继承，但一个类可以实现多个接口。使用`Runnable`接口的方式可以让类在继承其他类的同时实现多线程。 2. **资源共享**：多个线程可以共享同一个`Runnable`实例的成员变量（注意线程安全）。 3. **代码解耦**：线程任务（`Runnable`）与线程对象（`Thread`）分离，更符合面向对象的设计原则。 ### 注意事项： - 启动线程必须调用`start()`方法，而不是直接调用`run()`方法。直接调用`run()`方法只是在当前线程中执行，不会启动新线程。 - 多个线程共享同一个`Runnable`实例时，要注意线程安全问题，特别是当有共享数据时。 ### 引用说明： 本文中的实现步骤和示例代码参考了引用[1][^1]、[2][^2]、[3][^3]、[4][^4]和[5][^5]中关于Runnable接口创建线程的内容。 §§相关问题§§ 1. 使用Runnable接口和继承Thread类创建线程有什么区别？ 2. 如何实现多个线程共享同一个资源（如计数器）？需要注意什么？ 3. 如何控制多个线程的执行顺序？ 4. Java中还有哪些创建线程的方式？</think>### Java 通过实现 Runnable 接口创建线程教程 #### 一、核心机制 在 Java 中，`Runnable` 是一个函数式接口（只有一个抽象方法），通过实现它创建线程的机制是： 1. **解耦线程与任务**：线程对象（`Thread`）与任务逻辑（`run()`方法）分离 2. **静态代理模式**：`Thread` 类作为代理，执行 `Runnable` 的 `run()` 方法[^3][^4] 3. **资源共享**：多个线程可共享同一个 `Runnable` 实例[^5] #### 二、创建步骤 1. **实现 Runnable 接口** ```java public class MyTask implements Runnable { // 必须实现 run() 方法 @Override public void run() { // 线程执行的任务代码 for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + " 执行: " + i); } } } ``` 2. **创建线程对象** ```java public static void main(String[] args) { // 创建 Runnable 实例 Runnable task = new MyTask(); // 将 Runnable 传递给 Thread 构造器 Thread thread1 = new Thread(task, "工作线程-1"); Thread thread2 = new Thread(task, "工作线程-2"); } ``` 3. **启动线程** ```java thread1.start(); // 启动新线程执行 run() thread2.start(); // 启动第二个线程 // 主线程继续执行 System.out.println("主线程继续执行..."); ``` #### 三、完整示例 ```java public class RunnableDemo { public static void main(String[] args) { // 1. 创建任务实例 (Lambda简化版) Runnable task = () -> { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + " 计数: " + i); try { Thread.sleep(500); // 模拟耗时操作 } catch (InterruptedException e) { e.printStackTrace(); } } }; // 2. 创建并启动三个线程 new Thread(task, "线程-A").start(); new Thread(task, "线程-B").start(); new Thread(task, "线程-C").start(); System.out.println("所有线程已启动，主线程结束"); } } ``` #### 四、执行结果示例 ``` 所有线程已启动，主线程结束 线程-A 计数: 0 线程-B 计数: 0 线程-C 计数: 0 线程-A 计数: 1 线程-B 计数: 1 线程-C 计数: 1 线程-A 计数: 2 线程-B 计数: 2 线程-C 计数: 2 ``` #### 五、关键优势 1. **避免单继承限制**：类可同时继承其他类和实现接口[^5] 2. **资源共享**：多个线程共享同一任务对象状态 ```java // 共享计数器示例 class SharedCounter implements Runnable { private int count = 0; @Override public void run() { for (int i = 0; i < 1000; i++) { count++; // 需要同步控制 } } } ``` 3. **线程池友好**：可直接提交 `Runnable` 给线程池[^1] 4. **Lambda 简化**：Java 8+ 可使用 Lambda 表达式 ```java new Thread(() -> System.out.println("Lambda线程")).start(); ``` #### 六、注意事项 1. **不要直接调用 run()**：`thread.run()` 只会在当前线程执行 2. **线程安全**：共享资源需同步（`synchronized` 或 `Lock`） 3. **异常处理**：线程内异常需自行捕获 4. **状态管理**：使用 `Thread.currentThread().isInterrupted()` 检查中断 > 通过实现 `Runnable` 接口，可以更灵活地组织多线程代码，是 Java 并发编程的基础模式[^2][^3]。