Java基础-多线程

一、线程创建方式（两种写法，解决“怎么开启多任务”问题 ）

Java 里想让程序同时干多件事（比如一边下载、一边播放音乐 ），就得用多线程。而创建线程，最基础的就是继承 Thread 类和实现 Runnable 接口这两种方式，本质都是定义“线程要做的事（run() 方法 ）”，再启动线程让它执行。

1. 继承 Thread 类方式

// 第一步：自定义类继承 Thread，重写 run() 方法
class MyThread extends Thread {
// run() 里写的是“这个线程要执行的任务”
@Override
public void run() {
// 这里简单打印线程名称，实际可以是复杂逻辑（比如文件下载、数据处理等）
System.out.println("线程执行：" + Thread.currentThread().getName());
}
}

// 第二步：在 main 方法（主线程）里启动线程
public class Main {
public static void main(String[] args) {
// 创建自定义线程对象
MyThread t1 = new MyThread();
// 启动线程！注意：必须用 start()，不能直接调 run()！
// start() 会让 JVM 给线程分配资源（比如栈空间），然后自动调用 run() 执行任务
// 如果直接调 run()，就和普通方法调用一样，不会开启新线程，还是在主线程里执行
t1.start();
}
}

• 关键点：
  • 继承 Thread 后，run() 是线程的“任务入口”，JVM 会在启动线程后自动执行它。
  • start() 是真正“启动新线程”的关键方法，它会触发 JVM 的线程调度机制，给线程分配 CPU 时间片。
  • 缺点：Java 是单继承，要是你的类已经继承了其他类（比如 MyClass extends OtherClass ），就没法再继承 Thread 了，所以这种方式灵活性稍差。

2. 实现 Runnable 接口方式

// 第一步：自定义类实现 Runnable 接口，重写 run() 方法
class MyRunnable implements Runnable {
@Override
public void run() {
// 同样，这里定义线程要做的事，比如打印线程名
System.out.println("线程执行：" + Thread.currentThread().getName());
}
}

// 第二步：在 main 方法里，用 Thread 类“包装” Runnable 对象，再启动
public class Main {
public static void main(String[] args) {
// 创建 Runnable 任务对象（只是定义了任务，还没线程执行它）
MyRunnable runnableTask = new MyRunnable();
// 把任务丢给 Thread，让 Thread 来管理线程的启动、调度
Thread t2 = new Thread(runnableTask);
// 启动线程，和之前一样，start() 会触发 JVM 执行 run()
t2.start();
}
}

• 关键点：
  • Runnable 是个接口，只规定了 run() 方法，本身不涉及线程的“启动”能力。所以必须借助 Thread 类的构造方法，把 Runnable 任务“包装”进去，才能启动线程。
  • 优点：解决了单继承限制！比如MyRunnable 还能继承其他类（像 class MyRunnable extends OtherClass implements Runnable ），更灵活；而且，多个线程可以共享同一个 Runnable 对象（比如多个线程一起处理同一个任务队列 ）。

举个共享的例子：

MyRunnable sharedTask = new MyRunnable();
// 线程 A 和 线程 B 共享同一个任务对象
Thread tA = new Thread(sharedTask, "线程A");
Thread tB = new Thread(sharedTask, "线程B");
tA.start();
tB.start();

这样，线程 A 和 B 会基于同一个 sharedTask 执行任务，适合处理“多个线程协作完成同一份工作”的场景（比如共同处理一个计数器、一个文件写入操作 ）。

二、线程的生命周期（理解线程“一生”的状态变化 ）

线程从创建到销毁，会经历一系列状态变化，图里总结的流程是：

新建（New）→ 可运行（Runnable）→ 运行（Running）→（阻塞/等待/超时等待）→ 可运行 → 运行 → 终止（Terminated）

1. 新建（New）

• 场景：刚用 new 创建线程对象，还没调用 start() 的时候。比如 MyThread t1 = new MyThread(); 这一步，线程只是个“空壳”，JVM 还没给它分配真正的线程资源（比如栈、程序计数器等 ）。
• 此时程序没有任何变化，必须调 start() 才会进入下一步。

2. 可运行（Runnable）

• 场景：调用 start() 后，线程进入这个状态。此时，线程已经“准备好执行了”，但得等 CPU 调度（JVM 有个“线程调度器”，决定哪个线程先执行 ）。
• 注意：“可运行”不代表真的在执行，只是在“就绪队列”里排队，等 CPU 时间片。比如电脑同时开了很多程序，CPU 同一时间只能干一件事（多核 CPU 可以并行，但调度逻辑更复杂 ），所以得排队。

3. 运行（Running）

• 场景：CPU 选中了这个线程，开始执行 run() 方法里的代码，真正“干活”的状态。
• 能持续多久：取决于 CPU 时间片！时间片用完，线程会回到可运行状态，重新排队；如果 run() 里的代码很快执行完（比如就打印一句话 ），也会直接进入终止状态。

4. 阻塞/等待/超时等待（Blocked / Waiting / Timed Waiting）

这三类状态都是线程“暂停执行”的情况，原因不同，处理方式也不同：

• 阻塞（Blocked）：

  • 场景：线程想进入 synchronized 修饰的代码块/方法，但锁被其他线程占用了，就会进入阻塞状态，一直等到锁释放。

  • 例子： 线程 B 会卡在进入 synchronized 的地方，直到线程 A 释放锁。

    synchronized (lock) {
    // 假设线程 A 先拿到锁，线程 B 想进来就会阻塞
    }

• 等待（Waiting）：

  • 场景：线程调用了 wait()（必须在 synchronized 里调用 ）、join() 等方法，会进入“无限期等待”，直到被其他线程唤醒。

  • 例子：

    synchronized (lock) {
    // 线程调用 wait()，释放锁，进入等待
    lock.wait();
    // 必须等其他线程调用 lock.notify() 或 notifyAll()，才会被唤醒，回到可运行状态
    }

• 超时等待（Timed Waiting）：

  • 场景：线程调用了 sleep(long 毫秒)、wait(long 毫秒)、join(long 毫秒) 等方法，会进入“有限期等待”，到时间自动唤醒，或者提前被其他线程唤醒。

  • 例子： 或者：

    // 线程睡 3 秒，期间不占用 CPU，到时间自动回到可运行状态
    Thread.sleep(3000);

    synchronized (lock) {
    // 最多等 5 秒，要是没人唤醒，到时间也会自己醒
    lock.wait(5000);
    }

• 回到可运行状态：

  不管是阻塞、等待还是超时等待，只要“阻碍因素消失”（比如锁释放了、被其他线程唤醒了、超时时间到了 ），线程就会回到 可运行（Runnable） 状态，重新排队等 CPU 调度。

5. 终止（Terminated）

• 场景：run() 方法执行完毕（正常跑完所有代码 ），或者线程被强制中断（比如抛了未捕获的异常 ），线程就会进入终止状态，生命周期结束，不能再重启。
• 注意：线程终止后，就算调用 start() 也没用，会报错！线程对象一旦终止，就“报废”了，想再执行任务，得重新 new 一个。

三、线程常用方法

这些方法是 Thread 类或 Object 类（wait、notify 等是 Object 的方法 ）提供的，用来控制线程的状态、行为，解决“线程之间怎么配合、怎么调度”的问题。

四、线程同步与锁（解决“多线程抢资源”问题，避免数据混乱 ）

多线程同时访问共享资源（比如同一个变量、同一个文件 ）时，容易出现“数据竞争”，导致结果混乱。线程同步就是解决这个问题的，核心思路是让多个线程“有序访问”共享资源，常用 synchronized 和 Lock 接口两种方式。

1. synchronized 关键字（内置锁，简单直接 ）

synchronized 可以修饰方法或代码块，保证同一时间只有一个线程能进入“被保护的区域”，从而避免多线程冲突。

（1）修饰代码块（指定锁对象 ）

class BankAccount {
private int balance = 1000;
// 自定义锁对象（也可以用 this、字节码对象等当锁，看需求 ）
private final Object lock = new Object();

public void withdraw(int amount) {
// 同步代码块：只有拿到 lock 锁的线程，才能进这个块
synchronized (lock) {
if (balance >= amount) {
balance -= amount;
System.out.println(
Thread.currentThread().getName() + " 取款 " + amount + "，余额：" + balance
);
}
}
}
}

• 原理：线程想进入 synchronized (lock) 代码块，必须先拿到 lock 对象的“锁”。如果锁被其他线程占用，当前线程就会进入阻塞（Blocked） 状态，直到锁释放。这样就保证了，同一时间只有一个线程能修改 balance，避免多线程同时减余额导致数据错误。

（2）修饰方法（隐式锁对象 ）

• 修饰实例方法：

  public synchronized void withdraw(int amount) {
  // 锁对象是 this（当前实例）
  if (balance >= amount) {
  balance -= amount;
  }
  }

  相当于 synchronized (this) { … }，锁是当前对象实例。

• 修饰静态方法：

  public static synchronized void withdraw(int amount) {
  // 锁对象是 类的字节码对象（比如 BankAccount.class ）
  }

  相当于 synchronized (BankAccount.class) { … }，锁是类对象。

• 优缺点：

  优点：简单易用，JVM 自动管理锁的获取和释放（进入同步块自动拿锁，退出自动放锁，包括抛异常的情况 ）。

  缺点：不够灵活（比如想尝试获取锁、设置超时时间，synchronized 做不到 ）；如果同步范围太大，会影响性能（多个线程排队太久 ）。

2. Lock 接口（显式锁，更灵活 ）

java.util.concurrent.locks.Lock 是更灵活的锁机制，常用实现类是 ReentrantLock（可重入锁，和 synchronized 类似，同一线程可以多次拿锁 ）。

基本用法：

class BankAccount {
private int balance = 1000;
// 创建 Lock 对象，常用 ReentrantLock
private Lock lock = new ReentrantLock();

public void withdraw(int amount) {
// 手动加锁
lock.lock();
try {
// 临界区：操作共享资源的代码
if (balance >= amount) {
balance -= amount;
System.out.println(
Thread.currentThread().getName() + " 取款 " + amount + "，余额：" + balance
);
}
} finally {
// 手动释放锁！必须在 finally 里放，否则一旦代码抛异常，锁永远不会释放，导致死锁
lock.unlock();
}
}
}

• 原理：和 synchronized 类似，lock() 会尝试获取锁，拿到锁的线程才能执行临界区代码；执行完后，必须在 finally 里调用 unlock() 释放锁，保证锁一定能释放（即使代码抛异常 ）。

优点（对比 synchronized ）：

• 更灵活：

  • 可以尝试获取锁（tryLock() ），拿不到锁可以不等待，去做别的事；
  • 可以设置超时时间（tryLock(long time, TimeUnit unit) ），避免线程无限阻塞；
  • 可以实现更复杂的锁逻辑（比如读写锁 ReentrantReadWriteLock，读锁共享、写锁独占，适合读多写少的场景 ）。

• 可中断：

  lockInterruptibly() 方法允许在获取锁的过程中响应中断（比如等待锁时，其他线程调用了 interrupt()，可以提前放弃等待