S12L04 - 通过实现 Runnable 接口创建线程

### Chinese
html

通过实现Runnable接口在Java中创建线程：全面指南
目录

引言 ........................................................... 1
理解Java中的线程 ...................... 3

线程是什么？
为什么使用线程？


通过扩展Thread类创建线程

优缺点


通过实现Runnable接口创建线程

一步步实施
代码解释
程序输出


比较：扩展Thread vs. 实现Runnable
何时以及在哪里使用每种方法
结论 .............................................................. 15
附加资源 ......................................... 16

---
引言
在Java编程领域，multithreading（多线程）是一个关键概念，允许开发人员同时执行多个操作。这种能力不仅提高了应用程序的效率，还确保了资源的最佳利用。理解如何创建和管理线程对于构建响应迅速和高性能的Java应用程序至关重要。
本指南深入探讨Java中线程创建的基本方法之一：实现Runnable接口。我们将探索一步步的过程，提供详细的代码解释，并将这种方法与扩展Thread类进行比较。在本指南结束时，初学者和具备基础知识的开发人员将清晰了解如何使用Runnable接口创建线程。
实现Runnable的优点：

灵活性：允许扩展其他类，因为Java支持单继承。
关注点分离：将线程的执行逻辑与线程管理分开。
可重用性：Runnable对象可以与不同的Thread实例一起重用。

实现Runnable的缺点：

稍显冗长：相比扩展Thread类，需额外步骤。



方面
扩展Thread类
实现Runnable接口


继承
单继承
支持多继承


灵活性
不太灵活
更灵活


关注点分离
紧密耦合
松散耦合


可重用性
较少可重用
高度可重用


复杂性
实现简单
稍显冗长


何时使用实现Runnable：

当你的类需要扩展另一个类时。
当你想将线程的执行逻辑与线程管理分开时。
当你注重代码的更高灵活性和可重用性时。

---
理解Java中的线程
线程是什么？
Java中的thread（线程）是一个轻量级的子进程，最小的处理单元。它是程序内的一个独立执行路径，能够实现并发操作。线程共享相同的内存空间，这使得它们之间的通信高效，但也需要谨慎同步以避免冲突。
为什么使用线程？

提高性能：同时执行多个任务，有效利用CPU资源。
响应式应用程序：通过在独立线程中执行长时间运行的任务，保持应用的响应性。
资源共享：线程共享相同的内存，允许高效的通信和数据共享。

---
通过扩展Thread类创建线程
在深入了解Runnable接口之前，了解通过扩展Thread类创建线程的替代方法是必不可少的。
优缺点


优点
缺点


对于基本任务来说，实现更简单
Java中的单继承限制


直接访问Thread方法
相比Runnable不够灵活


---
通过实现Runnable接口创建线程
实现Runnable接口是Java中创建线程的首选方法，特别是当需要更大的灵活性和可重用性时。
一步步实施

实现Runnable接口：

   创建一个实现Runnable接口的类。这需要重写run()方法，线程的执行逻辑在这里。
重写run()方法：

   在run()方法中定义线程将执行的任务。
创建Thread实例：

   通过将Runnable实现传递给Thread的构造函数来实例化Thread对象。
启动线程：

   调用每个Thread实例的start()方法开始执行。

代码解释




		
		
			
			
Java
			
			
// MyCounter.java
package org.studyeasy;

import java.util.Random;

public class MyCounter implements Runnable {
    private int threadNumber;

    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    @Override
    public void run() {
        try {
            countMe();
            Random random = new Random();
            int sleepTime = random.nextInt(1000); // 随机睡眠时间在0-1000毫秒之间
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            System.out.println("线程 " + threadNumber + " 被中断。");
        }
    }

    public void countMe() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("线程 " + threadNumber + ": " + i);
        }
    }
}

// Main.java
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        MyCounter myCounter1 = new MyCounter(1);
        Thread thread1 = new Thread(myCounter1, "Thread-1");

        MyCounter myCounter2 = new MyCounter(2);
        Thread thread2 = new Thread(myCounter2, "Thread-2");

        thread1.start();
        thread2.start();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
				
						 
// MyCounter.java
package org.studyeasy;
 
import java.util.Random;
 
public class MyCounter implements Runnable {
    private int threadNumber;
 
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    @Override
    public void run() {
        try {
            countMe();
            Random random = new Random();
            int sleepTime = random.nextInt(1000); // 随机睡眠时间在0-1000毫秒之间
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            System.out.println("线程 " + threadNumber + " 被中断。");
        }
    }
 
    public void countMe() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("线程 " + threadNumber + ": " + i);
        }
    }
}
 
// Main.java
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        MyCounter myCounter1 = new MyCounter(1);
        Thread thread1 = new Thread(myCounter1, "Thread-1");
 
        MyCounter myCounter2 = new MyCounter(2);
        Thread thread2 = new Thread(myCounter2, "Thread-2");
 
        thread1.start();
        thread2.start();
    }
}
 
					
				
			
		


解释：

MyCounter 类：

实现Runnable接口。
包含一个threadNumber用于标识线程。
run()方法中包含countMe()方法，该方法打印从1到5的数字。
引入随机睡眠时间来模拟异步行为。


Main 类：

创建两个具有不同线程编号的MyCounter实例。
初始化两个Thread对象，传递相应的MyCounter实例。
使用start()方法启动两个线程。



程序输出




		
		
			
			
Java
			
			Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 1: 5
Thread 2: 1
Thread 2: 2
Thread 2: 3
Thread 2: 4
Thread 2: 5
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 1: 5
Thread 2: 1
Thread 2: 2
Thread 2: 3
Thread 2: 4
Thread 2: 5
					
				
			
		


注意：由于随机睡眠时间，线程执行的顺序可能在每次运行时有所不同。
---
比较：扩展Thread vs. 实现Runnable


特性
扩展Thread类
实现Runnable接口


继承
需要扩展Thread类
实现Runnable接口


灵活性
受限于单继承
可以扩展其他类


可重用性
可重用性较低
高度可重用


关注点分离
将线程逻辑与线程类结合在一起
将线程逻辑与线程管理分离


使用复杂性
适用于基本线程创建较简单
稍显冗长但更灵活


---
何时以及在哪里使用每种方法
扩展Thread类
使用时机：

当线程类是特定的，不需要扩展任何其他类时。
基本线程任务的最简单方法。

应用场景：

线程功能有限且紧密耦合的小型应用程序。

实现Runnable接口
使用时机：

当类需要扩展另一个类时。
当你需要更好地将线程逻辑与线程管理分离时。
当可重用性和灵活性是优先考虑时。

应用场景：

具有复杂线程需求的大型应用程序。
多个线程共享相同的Runnable实例的场景。

---
结论
使用Runnable接口在Java中创建线程提供了一种灵活且可重用的多线程方法。通过实现Runnable接口，开发人员可以将线程执行逻辑与线程管理分离，从而在复杂应用程序中实现更大的灵活性。虽然在基本任务中扩展Thread类实现更简单，但Runnable接口提供了增强的功能，对于坚固且可扩展的Java应用程序是不可或缺的。
关键要点：

实现Runnable：提供更好的灵活性和可重用性。
扩展Thread：更简单但由于单继承而不够灵活。
线程管理：在多线程环境中，正确的同步对于避免冲突至关重要。










该文章由AI生成。
---
附加资源

Oracle官方Java线程文档
Brian Goetz的《Java Concurrency in Practice》
TutorialsPoint Java多线程
Baeldung的线程与Runnable指南
方面	扩展Thread类	实现Runnable接口
继承	单继承	支持多继承
灵活性	不太灵活	更灵活
关注点分离	紧密耦合	松散耦合
可重用性	较少可重用	高度可重用
复杂性	实现简单	稍显冗长
优点	缺点
对于基本任务来说，实现更简单	Java中的单继承限制
直接访问Thread方法	相比Runnable不够灵活
特性	扩展Thread类	实现Runnable接口
继承	需要扩展Thread类	实现Runnable接口
灵活性	受限于单继承	可以扩展其他类
可重用性	可重用性较低	高度可重用
关注点分离	将线程逻辑与线程类结合在一起	将线程逻辑与线程管理分离
使用复杂性	适用于基本线程创建较简单	稍显冗长但更灵活
该文章由AI生成。