多线程机制

多线程机制

目标：理解线程与进程的区别、Java 多线程机制；掌握线程六状态生命周期（NEW/RUNNABLE/BLOCKED/WAITING/TIMED_WAITING/TERMINATED）；会用 extends Thread / implements Runnable 两种方式创建线程；理解 synchronized 同步与 join 联合，能解释竞态条件与死锁的四个必要条件。

一、为什么需要多线程

• 单线程瓶颈：Java 程序默认只有一个主线程，依次执行语句。若主线程里做一件耗时的事（读文件、网络请求、大计算），在它结束前整个程序都「卡住」——GUI 无法响应鼠标键盘，服务器无法接待下一个客户；
• 并发需求：把耗时任务交给独立线程，让「界面响应」与「后台计算」同时进行——这就是多线程要解决的问题；
• 进程 vs 线程：进程是操作系统分配资源的单位，线程是CPU 调度的单位。同一进程内的多个线程共享内存（堆上的对象、静态字段）——共享带来便利，也带来风险：竞态条件（后文第五节）；
• 真实场景（网络版 ERASE）：服务端每来一个客户端连接就 new 一个 ServThreadPerClient 线程专门处理它的收发——「一个客户端一个线程」；客户端的界面绘制与网络接收也分属不同线程并发执行。

二、线程的状态与生命周期

JVM 中每个线程对象有六个状态（java.lang.Thread.State）：

两个高频误区：

1. start() 不是直接执行 run()——它让线程进入 RUNNABLE，真正何时跑由调度器决定；
2. BLOCKED 只等锁——sleep/wait 是「等待」不是「阻塞」，两者在状态机里是不同的状态。

三、实现多线程的两种方法

方式一：继承 Thread 类——重写 run()，对象本身就是线程：

public class MyThread extends Thread {
    public void run() { /* 线程要执行的任务 */ }
}
// 启动：new MyThread().start();

方式二：实现 Runnable 接口——任务与线程分离，用 Thread 包装（课件 26/TicketSaler.java：三个售票点共用同一个任务对象）：

class TicketSaler implements Runnable {
    public void run() { /* 卖票任务 */ }
}
// 启动：Thread t = new Thread(new TicketSaler()); t.setName("张三"); t.start();

四、常用线程方法

• start()：启动线程进入 RUNNABLE；一个线程只能 start 一次，重复调用抛 IllegalThreadStateException；
• sleep(ms)：当前线程挂起 ms 毫秒（不释放已持有的锁）；声明抛出 InterruptedException，必须 try/catch；
• yield()：放弃当前时间片、回到就绪队列——只是「建议」，不保证立即让出；
• join()：联合——调用方线程挂起直到目标线程结束（课件 26/DemoThreadJoin.java：顾客线程 join 蛋糕师线程，蛋糕做完了顾客才继续）：

Thread customer = new Thread(a);   // 顾客
Thread cakeMaker = new Thread(a);  // 蛋糕师
a.setJoinThread(cakeMaker);        // 顾客任务里：cakeMaker.join()
customer.start();                  // 顾客先等蛋糕师结束，再继续买蛋糕

• setPriority(1~10)：优先级默认 5，只影响调度概率，不保证高优先级一定先执行。

五、线程同步 synchronized

竞态条件：多个线程交替读写同一份共享数据，最终结果取决于谁先谁后——错误就藏在「读-改-写」被拆开的缝隙里。典型反例是三个售票线程共用 tickets = 500：不加同步会卖出负数票、超卖。

修复：用 synchronized 保证同一时刻只有一个线程执行同步代码（课件 26/Thread/TicketsSaling_syn.java）：

public synchronized void sale() {   // 同步方法：拿到 this 的监视器锁才进得来
    if (tickets > 0) {
        Thread.sleep(1000);         // 模拟卖票耗时，放大并发窗口
        jta.append(Thread.currentThread().getName() + "售票" + tickets-- + "\n");
    }
}

• 同步方法：synchronized 加在方法上，锁是 this（实例方法）或类对象（静态方法）；
• 同步代码块：synchronized (obj) { ... }，锁是指定的 obj——锁范围尽量小，只包住共享数据的读-改-写；
• wait/notify 家族：Object 的 wait()/notify()/notifyAll() 只能在同步上下文中调用（先拿锁才能等）。课件 26/TicketSaler.java 的找零问题：李四给 20 元要换三张 5 元，若张三还没收够三张 5 元，李四线程 wait() 挂起；张三每收一张 5 元就 notifyAll() 唤醒大家重新检查——**「等条件不满足就 wait，条件可能满足就 notify」**是同步协作的基本套路。

六、生产者–消费者：synchronized 协作模拟

上一节的找零套路，推广到最经典的并发模型——生产者–消费者（Producer-Consumer）：生产者线程把「产品」放入一块共享缓冲，消费者线程从中取出。缓冲满 → 生产者必须 wait()；缓冲空 → 消费者必须 wait()；一方改变缓冲后调用 notifyAll() 唤醒对方。三个要点：

1. wait()/notifyAll() 只能在 synchronized 上下文中调用——先拿到监视器锁，才谈得上等与唤醒；
2. wait() 会释放锁并无限期挂起（WAITING 状态）；被唤醒后须重新拿锁、用 while 复查条件（用 if 会在多生产者场景下超产）；
3. 「条件不满足就 wait，条件可能满足就 notify」——谁在等、谁拿着锁，下面逐步看。

public synchronized void produce(int item) {
    while (size == buf.length)        // 缓冲满 → 条件不满足就 wait
        try { wait(); } catch (InterruptedException e) {}
    buf[(head + size) % buf.length] = item;
    size++;
    notifyAll();                     // 条件可能已满足 → 唤醒等待者
}

public synchronized int consume() {
    while (size == 0)                 // 缓冲空 → 条件不满足就 wait
        try { wait(); } catch (InterruptedException e) {}
    int v = buf[head];                // 取出队首产品
    head = (head + 1) % buf.length;
    size--;
    notifyAll();                     // 条件可能已满足 → 唤醒等待者
    return v;
}

七、优先级与调度：谁先跑？

多个线程都就绪（RUNNABLE）之后，CPU 一次只能执行一个——调度器每一步从就绪队列里挑一个来跑。Java 给每个线程设了 1~10 的优先级（默认 5）：优先级越高越容易被挑中，但只是概率更高，不保证一定先执行。下面的模拟用「最高优先级优先、同级轮转」的确定策略把这一效果夸张化，三种对照：

• 同优先级：公平轮转，没有线程被饿死；
• 优先级不同：高优先级线程先跑完，低优先级依次收尾——顺序被改变；
• 长时运行的高优先级任务：一直占着 CPU → 低优先级线程拿不到时间片，即饿死（真实系统用「老化」机制——随等待时间逐渐提升线程优先级——来防止）。

Thread t1 = new Thread(task, "PrintTask");      // 默认优先级 5
Thread t2 = new Thread(task, "AudioMixTask");
t2.setPriority(Thread.MAX_PRIORITY);   // 请求优先被调度（优先级 10）
t1.start();
t2.start();                            // 两者都就绪时，t2 获得 CPU 的概率更高

八、总结：死锁与同步要点

• 死锁四必要条件（缺一即无死锁）：互斥（资源一次只给一个线程）、占有并等待（拿着 A 等 B）、不可抢占（锁只能自己释放）、循环等待（甲等乙、乙等甲）；
• 预防思路：按固定顺序申请多把锁（破坏循环等待）；用 tryLock 类机制超时放弃（破坏占有并等待）；
• 同步使用要点：锁范围最小化；同步块内不要调用可能阻塞的业务方法（如 sleep、IO），否则排队线程越积越多。

思考题

1. start() 之后线程一定立刻执行 run() 吗？RUNNABLE 包含哪两种情形？
2. 三个售票线程共用一个 tickets 变量，不加 synchronized 会出现什么现象？加在方法上和加在代码块上，锁的范围有何不同？
3. 网络版 ERASE「一个客户端一个线程」的设计，如果客户端数量很大（如上万），这种设计会遇到什么问题？（提示：线程创建与调度的开销）

学习小测验