好的，各位观众老爷，各位程序媛，大家好！我是你们的老朋友，Bug终结者，代码诗人，今天咱们来聊聊Java多线程编程里的一对好基友：Thread和Runnable。
准备好了吗？系好安全带，咱们要发车啦！
开场白：多线程的世界，如诗如画
想象一下，你在厨房里同时炖着汤、炒着菜、烤着面包，还要时不时地去看看电视，这不就是现实生活中的多线程吗？没有多线程，你就只能做完一件事情才能做另一件，那效率得多低下啊！ 放到计算机的世界，单线程就像一个苦逼的码农，只能按部就班地执行任务，而多线程就像一群码农一起干活，效率瞬间提升N个档次！
多线程，它就像一首气势磅礴的交响乐，不同的乐器（线程）各司其职，共同演奏出美妙的乐章。它又像一幅色彩斑斓的油画，不同的颜色（线程）相互交织，构成一幅充满活力的画面。 掌握了多线程，你就能让你的程序跑得更快，响应更及时，用户体验更好，简直就是走向人生巅峰的必备技能啊！ 🚀
第一幕：Thread——线程本尊，霸气登场
首先，咱们来认识一下Thread类，它可是Java多线程的老大哥，线程的“亲爹”。
Thread类代表一个线程，它封装了线程的所有属性和行为。你可以直接继承Thread类，然后重写它的run()方法，这个run()方法就是线程要执行的任务。
class MyThread extends Thread {
@Override
public void run() {
// 这里写线程要执行的任务
System.out.println("我是Thread类，我在执行任务！");
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动线程
}
}这段代码就像在舞台上拉开了大幕，MyThread缓缓登场，它继承了Thread类，并且重写了run()方法，这个run()方法就是它的独角戏。通过调用thread.start()，我们启动了这个线程，让它开始执行run()方法里的任务。
优点：
- 简单直接，易于理解。
- 可以直接访问Thread类的各种方法，例如
getName()、getId()、getPriority()等。
缺点：
- Java是单继承的，如果你的类已经继承了其他的类，就不能再继承Thread类了。 这就像相亲，你已经名花有主了，就不能再跟别人眉来眼去了。 💔
- 耦合度较高，线程的逻辑和类的逻辑紧密耦合在一起，不利于代码的维护和扩展。
第二幕：Runnable——接口化身，灵活百变
为了解决Thread类的单继承问题，Java提供了Runnable接口。 Runnable接口只有一个方法：run()。 任何实现了Runnable接口的类，都可以作为线程的任务来执行。
class MyRunnable implements Runnable {
@Override
public void run() {
// 这里写线程要执行的任务
System.out.println("我是Runnable接口，我在执行任务！");
}
}
public class Main {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable); // 将Runnable对象作为Thread的构造参数
thread.start(); // 启动线程
}
}这段代码就像一个魔术师，MyRunnable实现了Runnable接口，它就像一个演员，准备好了自己的剧本（run()方法）。然后，我们用Thread类将这个演员包装起来，让它登上舞台（启动线程）。
优点：
- 可以避免单继承的限制，一个类可以实现多个接口。 这就像海王，可以同时拥有多个女朋友。 咳咳，开个玩笑。 😉
- 解耦度高，线程的逻辑和类的逻辑分离，有利于代码的维护和扩展。
- 更符合面向对象的设计原则，将任务和线程分离。
缺点：
- 不能直接访问Thread类的某些方法，需要通过
Thread.currentThread()来获取当前线程对象。 - 代码稍微复杂一些，需要先创建Runnable对象，再创建Thread对象。
第三幕：Thread vs Runnable——巅峰对决，谁与争锋？
现在，Thread和Runnable都登场了，那么问题来了，到底该选择哪一个呢？ 让我们来一场巅峰对决，看看谁更胜一筹！
| 特性 | Thread 类 | Runnable 接口 |
|---|---|---|
| 继承 | 继承Thread类 | 实现Runnable接口 |
| 单继承限制 | 受单继承限制 | 无单继承限制 |
| 耦合度 | 耦合度高 | 解耦度高 |
| 设计原则 | 不符合面向对象设计原则 | 更符合面向对象设计原则 |
| 代码复杂度 | 简单直接 | 稍微复杂 |
| 访问Thread方法 | 可以直接访问 | 需要通过Thread.currentThread()来获取当前线程对象 |
总的来说，Runnable接口更灵活，更符合面向对象的设计原则，因此在实际开发中，我们通常更推荐使用Runnable接口。
第四幕：深入剖析，细节决定成败
光说不练假把式，咱们来深入剖析一下Thread和Runnable的底层原理，看看它们是如何工作的。
- Thread类的
start()方法： 这个方法并不是直接执行run()方法，而是创建一个新的线程，然后在新的线程中执行run()方法。 这就像雇佣了一个工人，让他去执行任务，而不是你自己亲自上阵。 - Runnable接口的
run()方法： 这个方法只是定义了线程要执行的任务，它本身并不会创建新的线程。 需要将Runnable对象作为Thread的构造参数，才能让线程执行这个任务。 这就像准备好了食材，还需要厨师来烹饪才能变成美味佳肴。
第五幕：实战演练，代码说话
说了这么多理论，咱们来点实际的，用代码来演示一下Thread和Runnable的用法。
场景： 模拟多个窗口同时售票。
使用Thread类：
class TicketThread extends Thread {
private int tickets = 10; // 总票数
@Override
public void run() {
while (tickets > 0) {
System.out.println(Thread.currentThread().getName() + " 售出第 " + tickets + " 张票");
tickets--;
try {
Thread.sleep(100); // 模拟售票时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
TicketThread thread1 = new TicketThread();
TicketThread thread2 = new TicketThread();
TicketThread thread3 = new TicketThread();
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}使用Runnable接口：
class TicketRunnable implements Runnable {
private int tickets = 10; // 总票数
@Override
public void run() {
while (tickets > 0) {
System.out.println(Thread.currentThread().getName() + " 售出第 " + tickets + " 张票");
tickets--;
try {
Thread.sleep(100); // 模拟售票时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
TicketRunnable runnable = new TicketRunnable();
Thread thread1 = new Thread(runnable, "窗口1");
Thread thread2 = new Thread(runnable, "窗口2");
Thread thread3 = new Thread(runnable, "窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}通过对比这两段代码，我们可以发现，使用Runnable接口的代码更加灵活，我们可以创建多个线程来执行同一个Runnable对象，从而实现资源共享。
第六幕：线程池——线程管理的利器
如果每次需要线程都去创建，用完就销毁，会消耗大量的系统资源。为了解决这个问题，Java提供了线程池。 线程池可以预先创建一些线程，并将它们放在一个池子里，当需要线程时，就从池子里取一个，用完后再放回池子里，避免了频繁创建和销毁线程的开销。
线程池就像一个共享单车停车场，你需要用车的时候，直接从停车场取一辆，用完后再放回去，方便快捷。
第七幕：线程安全——多线程的阿喀琉斯之踵
多线程虽然可以提高程序的效率，但也带来了线程安全问题。 多个线程同时访问共享资源时，可能会导致数据不一致，程序崩溃等问题。
线程安全就像潘多拉魔盒，一旦打开，各种妖魔鬼怪就会跑出来，让你防不胜防。
为了解决线程安全问题，我们需要使用各种同步机制，例如：
- synchronized关键字： 用于保护共享资源，确保同一时刻只有一个线程可以访问。
- Lock接口： 提供了比synchronized关键字更强大的同步功能。
- volatile关键字： 用于保证变量的可见性，确保所有线程都能看到变量的最新值。
- 原子类： 提供了一些原子操作，例如
AtomicInteger、AtomicLong等，可以保证操作的原子性。
第八幕：总结与展望——多线程的未来，无限可能
今天，我们一起探索了Java多线程编程的Thread和Runnable，了解了它们的区别和用法，也认识到了线程安全的重要性。
多线程编程是一个复杂而有趣的领域，它充满了挑战，也充满了机遇。 掌握了多线程编程，你就能让你的程序跑得更快，响应更及时，用户体验更好，成为真正的编程高手！
未来，随着硬件技术的不断发展，多核处理器将越来越普及，多线程编程也将变得越来越重要。 让我们一起努力，不断学习，掌握多线程编程的精髓，迎接多线程时代的到来！
结尾：
感谢各位的观看，希望今天的讲解对大家有所帮助。 如果你觉得这篇文章写得还不错，请点个赞，转发一下，让更多的人了解Java多线程编程的魅力！
下次再见！ 👋