一、先给一道例题
在现实生活中,火车站有三个售票窗口同时售卖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
练习建议:可以尝试修改上述代码,使用两个线程分别模拟两个不同的角色(比如生产者线程生产面包,消费者线程消费面包),锻炼处理多线程间协调通信的能力。





