【Java基础-47.1】Java中通过继承Thread类创建线程

在Java中，多线程编程是实现并发操作的重要手段之一。Java提供了多种创建线程的方式，其中一种是通过继承Thread类来创建线程。本文将详细介绍如何通过继承Thread类创建线程，并探讨其使用场景、优缺点以及注意事项。

---

1. 什么是Thread类？

Thread类是Java中用于表示线程的核心类。它位于java.lang包中，提供了线程的创建、启动、暂停、中断等操作。每个Thread对象都代表一个独立的执行线程。

通过继承Thread类，我们可以重写其run()方法，定义线程的具体执行逻辑。当线程启动时，run()方法中的代码将会被执行。

---

2. 通过继承Thread类创建线程的步骤

通过继承Thread类创建线程的步骤如下：

2.1 创建一个继承Thread类的子类

首先，我们需要创建一个类并继承Thread类。然后，重写run()方法，在run()方法中定义线程的执行逻辑。

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的代码
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
        }
    }
}

2.2 创建线程对象并启动线程

在主程序中，创建该子类的对象，并调用start()方法启动线程。start()方法会调用run()方法，使线程进入就绪状态，等待CPU调度。

public class Main {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        // 启动线程
        thread1.start();
        thread2.start();
    }
}

2.3 运行结果

运行上述代码，你会看到两个线程交替执行，输出类似以下内容：

Thread-1 - 0
Thread-0 - 0
Thread-1 - 1
Thread-0 - 1
Thread-1 - 2
Thread-0 - 2
Thread-1 - 3
Thread-0 - 3
Thread-1 - 4
Thread-0 - 4

---

3. 继承Thread类的优缺点

3.1 优点

• 简单易用：继承Thread类的方式直观易懂，适合初学者快速上手。
• 直接调用线程方法：由于子类本身就是Thread类，可以直接调用Thread类的方法，如getName()、setPriority()等。

3.2 缺点

• 单继承限制：Java是单继承语言，如果一个类已经继承了其他类，就无法再继承Thread类。
• 代码耦合性高：将线程逻辑与业务逻辑耦合在一起，不利于代码的复用和维护。

---

4. 使用场景

继承Thread类的方式适合以下场景：

• 简单的多线程任务，不需要复杂的线程管理。
• 线程的逻辑与业务逻辑紧密相关，且不需要复用线程代码。
• 需要直接使用Thread类的方法（如设置线程优先级、名称等）。

---

5. 注意事项

5.1 不要直接调用run()方法

run()方法是线程的执行逻辑，但直接调用run()方法并不会启动新线程，而是在当前线程中同步执行。启动线程必须调用start()方法。

MyThread thread = new MyThread();
thread.run();  // 错误：不会启动新线程
thread.start(); // 正确：启动新线程

5.2 线程安全问题

多个线程共享资源时，可能会出现线程安全问题。例如，多个线程同时修改同一个变量可能导致数据不一致。此时需要使用同步机制（如synchronized关键字或Lock）来保证线程安全。

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

5.3 线程的生命周期

线程的生命周期包括新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和终止（Terminated）等状态。理解线程的生命周期有助于更好地管理线程。

创建线程对象

start()

线程调度器选择执行

yield() 或时间片用完

等待锁

获取锁

wait()

notify()/notifyAll()

sleep() 或 wait(timeout)

超时或唤醒

run() 执行完毕

New

Runnable

Running

Blocked

Waiting

TimedWaiting

Terminated

详细说明：

1. 新建（New）
   • 线程对象被创建，但尚未调用start()方法。
   • 示例：Thread thread = new Thread();
2. 就绪（Runnable）
   • 调用start()方法后，线程进入就绪状态，等待线程调度器分配CPU时间片。
   • 示例：thread.start();
3. 运行（Running）
   • 线程调度器选择该线程执行，线程开始运行run()方法中的代码。
4. 阻塞（Blocked）
   • 线程等待获取锁（例如进入synchronized块时锁被其他线程占用）。
   • 当锁可用时，线程从阻塞状态回到就绪状态。
5. 等待（Waiting）
   • 线程调用wait()方法，进入等待状态，直到其他线程调用notify()或notifyAll()唤醒它。
   • 示例：object.wait();
6. 超时等待（Timed Waiting）
   • 线程调用sleep(timeout)或wait(timeout)方法，进入超时等待状态。
   • 当超时时间到达或收到唤醒信号时，线程回到就绪状态。
   • 示例：Thread.sleep(1000);
7. 终止（Terminated）
   • 线程的run()方法执行完毕或线程被强制终止（如调用stop()方法，不推荐使用）。
   • 线程生命周期结束。

---

6. 示例：多线程下载文件

以下是一个通过继承Thread类实现多线程下载文件的示例：

public class DownloadThread extends Thread {
    private String url;
    private String fileName;

    public DownloadThread(String url, String fileName) {
        this.url = url;
        this.fileName = fileName;
    }

    @Override
    public void run() {
        System.out.println("开始下载: " + fileName);
        // 模拟下载过程
        try {
            Thread.sleep(2000); // 模拟下载耗时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("下载完成: " + fileName);
    }
}

public class Main {
    public static void main(String[] args) {
        DownloadThread thread1 = new DownloadThread("http://example.com/file1.zip", "file1.zip");
        DownloadThread thread2 = new DownloadThread("http://example.com/file2.zip", "file2.zip");

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

运行结果：

开始下载: file1.zip
开始下载: file2.zip
下载完成: file1.zip
下载完成: file2.zip

---

7. 总结

通过继承Thread类创建线程是Java多线程编程的一种基本方式。它的优点是简单易用，适合初学者快速上手；缺点是单继承限制和代码耦合性较高。在实际开发中，如果需要更灵活的方式，可以考虑实现Runnable接口或使用线程池。