欢迎光临
我们一直在努力

Java面向对象程序设计——Thread子类 vs Runnable接口创建线程

一、先给一道例题

在现实生活中,火车站有三个售票窗口同时售卖100张火车票。每个窗口都是一个独立的线程,但它们需要共同处理“总共100张票”这一共享资源。请用Java的多线程机制模拟火车票售票系统,要求如下:

  • 分别使用 继承Thread类 和 实现Runnable接口 两种方式来创建线程,模拟三个窗口同时卖票。

  • 总票数为100张,所有窗口共享这100张票的票源。

  • 每个窗口卖出一张票后,总票数减1,并输出“窗口X卖出一张票,剩余X张”。

  • 当票数为0时,停止售票。

  • 观察并对比两种方式在实现上的差异。

  • 二、解题思路

    2.1 为什么要创建线程

    计算机的CPU在执行程序时,实际上是在多个任务之间快速切换,营造出“同时运行”的假象。多线程就是让一个程序内部的不同任务可以“看似同时”地执行,从而提高CPU利用率和程序的响应速度。Java程序启动时会自动创建一个主线程(即执行main方法的线程),而我们需要学习的就是如何主动创建新的线程。

    2.2 Java创建线程的三种方式

    Java中创建线程主要有三种方式:继承Thread类、实现Runnable接口、以及使用Callable和Future创建线程。

    本题聚焦于前两种方式的对比:

    • 继承Thread类:定义Thread类的子类,重写其run()方法,然后创建子类实例并调用start()方法启动线程。

    • 实现Runnable接口:定义一个实现Runnable接口的类,重写run()方法,创建该类的实例作为“任务对象”,再将其作为参数传给Thread类的构造器创建Thread对象,最后调用start()方法启动线程。

    2.3 两种方式的核心差异

    继承Thread类的方式:线程的任务代码与线程本身完全绑定,每个Thread子类的对象代表一个独立的线程实例。这种方式简单直接,但存在一个关键限制——Java不支持多重继承,如果一个类已经继承了其他父类,就无法再通过继承Thread类来创建线程。此外,各线程对象之间无法天然共享数据,要实现资源共享必须借助static变量,而这通常不是最优雅的写法。

    实现Runnable接口的方式:将一个“任务”(Runnable对象)与“线程”(Thread对象)分离开来。Runnable只定义了“要做什么”,而Thread负责“如何调度执行”。这种方式没有单继承的限制,可以实现多个接口,更加灵活。同时,多个线程可以共享同一个Runnable实例,从而轻松实现资源的共享。

    2.4 多线程的资源共享问题

    在本题的售票场景中,三个窗口需要共享“100张票”这一公共资源。如果处理不当,可能会出现两个线程同时卖出同一张票的“超卖”问题。虽然本题的例题暂不涉及复杂的线程同步(这部分属于synchronized关键字的范畴),但理解“共享资源”的重要性,正是Runnable接口相对于Thread类的显著优势所在——因为通过Runnable接口,可以非常自然地让多个线程共享同一个实例对象。

    三、代码实现与逐行解释

    3.1 方式一:继承Thread类

    java

    /**
    * 方式一:继承Thread类 – 创建三个独立的Thread子类对象,每个对象各自卖票
    * 注意:由于每个线程拥有独立的实例,totalTickets必须用static修饰,才能实现共享
    */
    class TicketWindow extends Thread {
    // 总票数:设置为静态变量,所有线程对象共享
    private static int totalTickets = 100;

    // 窗口名称
    private String windowName;

    // 构造方法:传入窗口名称
    public TicketWindow(String windowName) {
    this.windowName = windowName;
    }

    @Override
    public void run() {
    // 循环售票,直到票卖完
    while (true) {
    // 先判断是否还有余票
    if (totalTickets > 0) {
    // 模拟出票延迟(为了更清晰地看到多线程交替执行的效果)
    try {
    Thread.sleep(10);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }

    // 卖出一张票,总票数减1
    System.out.println(windowName + "卖出一张票,剩余票数:" + (–totalTickets));
    } else {
    System.out.println(windowName + "票已售完,停止售票");
    break;
    }
    }
    }
    }

    /**
    * 测试类 – 使用继承Thread类方式创建三个售票窗口
    */
    public class ThreadVsRunnableDemo1 {
    public static void main(String[] args) {
    // 创建三个售票窗口(每个都是独立的线程对象)
    TicketWindow window1 = new TicketWindow("窗口1");
    TicketWindow window2 = new TicketWindow("窗口2");
    TicketWindow window3 = new TicketWindow("窗口3");

    // 启动三个线程,开始售票
    window1.start();
    window2.start();
    window3.start();
    }
    }

    运行结果(示例):

    text

    窗口1卖出一张票,剩余票数:99
    窗口2卖出一张票,剩余票数:98
    窗口3卖出一张票,剩余票数:97
    …
    (继续输出直到0)

    3.2 逐行代码解释(方式一)

    ① 类定义与静态变量

    java

    class TicketWindow extends Thread {
    private static int totalTickets = 100;

    • extends Thread:TicketWindow类继承了Thread类,从而具备了线程的能力。

    • private static int totalTickets:static是关键所在。因为在继承Thread的方式下,每创建一个线程对象(如window1、window2、window3)都是一个独立的实例,如果没有static,每个实例都会拥有自己独立的totalTickets变量,导致三个窗口各卖100张票,总共卖了300张。static使得变量属于类级别,被所有实例共享。

    ② 构造方法与属性

    java

    private String windowName;

    public TicketWindow(String windowName) {
    this.windowName = windowName;
    }

    • 通过构造方法为每个窗口设置不同的名称,方便在输出中区分。

    ③ 重写run()方法

    java

    @Override
    public void run() {
    while (true) {
    if (totalTickets > 0) {
    Thread.sleep(10);
    System.out.println(windowName + "卖出一张票,剩余票数:" + (–totalTickets));
    } else {
    break;
    }
    }
    }

    • @Override:注解表示重写父类的方法,可以帮助编译器检查是否正确地重写了run()方法。

    • while (true):无限循环,持续进行售票,直到票卖完才通过break退出。

    • Thread.sleep(10):让当前线程暂停10毫秒。加上这一行是为了让线程的执行交替得更明显,观察多线程的并发效果;不加这一行时,线程执行速度极快,往往一个线程就将所有票“抢”完了。

    • –totalTickets:先减1,再输出剩余票数。注意这一操作并非原子操作,在实际的多线程并发场景中,这段代码存在线程安全问题(可能会出现重复卖票或负数票的问题),但本例题暂不展开线程同步的知识。

    ④ 启动线程

    java

    window1.start();
    window2.start();
    window3.start();

    • start()方法的作用是启动一个新线程,让JVM在新的线程中执行run()方法中的代码。千万不要写成window1.run(),那样只是在当前线程中调用一个普通方法,并不会创建新线程。

    3.3 方式二:实现Runnable接口

    java

    /**
    * 方式二:实现Runnable接口 – 创建一个Runnable任务对象,交给三个Thread线程执行
    * 注意:totalTickets不需要static,因为三个线程共享同一个Runnable实例
    */
    class TicketTask implements Runnable {
    // 总票数:普通成员变量即可,因为多个线程共享同一个Runnable实例
    private int totalTickets = 100;

    @Override
    public void run() {
    // 获取当前线程的名称(即窗口号)
    String threadName = Thread.currentThread().getName();

    // 循环售票
    while (true) {
    // 先判断是否还有余票
    if (totalTickets > 0) {
    // 模拟出票延迟
    try {
    Thread.sleep(10);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }

    // 卖出一张票,总票数减1
    System.out.println(threadName + "卖出一张票,剩余票数:" + (–totalTickets));
    } else {
    System.out.println(threadName + "票已售完,停止售票");
    break;
    }
    }
    }
    }

    /**
    * 测试类 – 使用实现Runnable接口方式创建三个售票窗口
    */
    public class ThreadVsRunnableDemo2 {
    public static void main(String[] args) {
    // 创建一个Runnable任务对象(只需要创建一个!)
    TicketTask task = new TicketTask();

    // 创建三个Thread对象,将同一个Runnable任务对象传入
    Thread window1 = new Thread(task, "窗口1");
    Thread window2 = new Thread(task, "窗口2");
    Thread window3 = new Thread(task, "窗口3");

    // 启动三个线程,开始售票
    window1.start();
    window2.start();
    window3.start();
    }
    }

    3.4 逐行代码解释(方式二)

    ① 实现Runnable接口

    java

    class TicketTask implements Runnable {
    private int totalTickets = 100;

    • implements Runnable:实现Runnable接口,表明这个类的对象可以作为一个“任务”被线程执行。

    • private int totalTickets:这里不需要static。因为在main方法中只创建了一个TicketTask实例(TicketTask task = new TicketTask()),三个Thread对象都指向同一个任务实例,所以totalTickets天然地被三个线程共享。

    ② 获取线程名称

    java

    String threadName = Thread.currentThread().getName();

    • Thread.currentThread()是一个静态方法,返回当前正在执行的线程对象。

    • getName()返回该线程的名称。使用Thread类的构造方法传入了“窗口1”“窗口2”“窗口3”等名称,因此这里可以获取到对应的窗口名。

    ③ 创建Thread对象

    java

    TicketTask task = new TicketTask();
    Thread window1 = new Thread(task, "窗口1");
    Thread window2 = new Thread(task, "窗口2");
    Thread window3 = new Thread(task, "窗口3");

    • 将同一个Runnable任务对象task作为参数传入三个不同的Thread构造器中,并分别命名为“窗口1”“窗口2”“窗口3”。

    • 这种设计模式被称为“任务与执行分离”:TicketTask只负责定义“卖票”这个业务逻辑(什么是任务),而Thread对象负责管理线程的启动、调度、生命周期(如何执行任务)。两个职责被清晰地分开了。

    ④ 启动线程

    java

    window1.start();
    window2.start();
    window3.start();

    • 与方式一相同,调用start()方法启动三个线程,让三个窗口同时开始售票。

    四、总结

    通过售票系统这个例题的两种实现方式,我们可以总结出以下核心要点:

    继承Thread类的特点

    • 代码编写简单直观,适合初学者快速理解线程的概念

    • 每个线程对象都是独立的实例,如果需要共享数据必须依靠static变量

    • 由于Java不支持多继承,如果类已有父类则无法使用此方式,存在灵活性受限的问题

    • 任务代码与线程本身紧密耦合,不利于代码复用

    实现Runnable接口的特点

    • 将“任务”与“线程”分离,任务逻辑可以独立于线程创建和管理

    • 没有单继承的限制,实现了Runnable的类还可以继承其他类或实现其他接口

    • 多个线程可以共享同一个Runnable实例,天然支持资源共享,无需使用static

    • 代码更加清晰,符合单一职责原则,便于后期维护和扩展

    • 实际开发中更推荐使用这种方式

    两种方式的相同点

    • 都需要重写run()方法,将线程要执行的逻辑声明在run()方法中

    • run()方法中编写的是线程执行体,线程启动后就会执行其中的代码

    • Thread类本身也实现了Runnable接口,这是两种方式存在内在联系的根本原因

    启动线程的关键注意点

    • 启动线程必须调用start()方法,而不是直接调用run()方法

    • start()会让JVM创建一个新线程并在其中执行run()方法

    • 直接调用run()只是在当前线程中执行一个普通方法调用,不会产生新线程

    • 同一个线程对象不能重复调用start(),否则会抛出IllegalThreadStateException

    使用场景建议

    • 对于简单的、不需要资源共享的独立线程任务,继承Thread类可以快速实现

    • 对于需要资源共享、代码复用、或类已有其他父类的情况,优先选择Runnable接口

    • 对于追求代码极简的开发者,还可以结合匿名内部类或Lambda表达式使用

    五、更多练习题目推荐

    以下是可以直接访问的Java多线程相关练习题(请复制链接后自行替换 [colon] 为 :,[dot] 为 .):

    https://blog.csdn.net/m0_52826559/article/details/132440012

    https://blog.csdn.net/li_peining/article/details/129773689

    https://blog.csdn.net/qq_47146387/article/details/134178465

    https://www.nowcoder.com/practice/2e5e331d9cfc4010b9a5cf0faa2de3c9

    https://blog.51cto.com/u_15955198/6106081

    https://blog.51cto.com/u_15255162/6078697

    练习建议:可以尝试修改上述代码,使用两个线程分别模拟两个不同的角色(比如生产者线程生产面包,消费者线程消费面包),锻炼处理多线程间协调通信的能力。

    赞(0)
    未经允许不得转载:171主机测评 » Java面向对象程序设计——Thread子类 vs Runnable接口创建线程
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址