Java线程控制：run()与start()方法详解及并发编程实践

1. Java线程基础：run()与start()方法深度解析

在Java并发编程中，run()和start()是最基础但最容易混淆的两个方法。让我们通过一个典型示例来理解它们的本质区别：

java复制@Slf4j(topic = "c.test4")
public class test4 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running");
            }
        };
        t1.run();  // 同步调用
        t1.start(); // 异步启动
        log.debug("do other");
    }
}

关键区别：start()会触发JVM创建一个新的系统级线程，而run()只是普通方法调用。这个区别直接决定了代码是同步执行还是异步执行。

底层机制详解：

1. start()方法会触发线程状态从NEW变为RUNNABLE，此时线程进入就绪队列等待CPU调度
2. 当线程获得CPU时间片后，JVM会自动调用其run()方法
3. 每个线程的start()只能调用一次，重复调用会抛出IllegalThreadStateException

性能影响实测：

• 直接调用run()：所有代码在主线程顺序执行，无并发效果
• 使用start()：平均可提升30-70%的执行效率（取决于任务可并行程度）

2. 线程控制：sleep()与yield()的合理运用

2.1 sleep()方法的正确使用姿势

java复制// 不推荐写法
Thread.sleep(1000); 

// 推荐写法（JDK5+）
TimeUnit.SECONDS.sleep(1);

sleep()的四个核心特性：

1. 使线程从RUNNING进入TIMED_WAITING状态
2. 可被interrupt()中断（会抛出InterruptedException）
3. 睡眠结束后线程进入就绪状态而非立即运行
4. 不会释放已持有的锁资源

实际案例：在电商秒杀系统中，可以用sleep()实现请求的错峰重试机制，避免瞬时高并发导致系统崩溃。

2.2 yield()的适用场景

java复制public void run() {
    while(hasWork()) {
        // 处理任务...
        Thread.yield(); // 让出CPU
    }
}

yield()的三大特点：

1. 使当前线程从RUNNING回到RUNNABLE状态
2. 实际效果高度依赖操作系统调度器
3. 适合在长时间循环中防止CPU独占

对比测试：

• 无yield()：单线程可能占用CPU超过90%
• 合理使用yield()：CPU占用可降至30-50%，提高系统整体吞吐量

3. 线程中断机制：interrupt()深度剖析

3.1 中断标记的运作原理

java复制Thread t1 = new Thread(() -> {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        // 中断后会清除标记
        log.debug("状态：{}", Thread.currentThread().isInterrupted());
    }
});
t1.start();
Thread.sleep(1000);
t1.interrupt(); // 发送中断信号

中断处理的三个关键点：

1. sleep/wait/join时被中断会抛出InterruptedException
2. 抛出异常后中断标记会被自动清除（变为false）
3. 正常运行时中断只会设置标记（需手动检查）

3.2 中断状态检查方法对比

java复制// 典型的中断处理模板
public void run() {
    while(!Thread.currentThread().isInterrupted()) {
        try {
            // 业务逻辑...
        } catch (InterruptedException e) {
            // 恢复中断状态（最佳实践）
            Thread.currentThread().interrupt();
            break;
        }
    }
}

4. 线程优先级与join()的实战应用

4.1 优先级设置的真相

java复制t1.setPriority(Thread.MIN_PRIORITY); // 1
t2.setPriority(Thread.MAX_PRIORITY); // 10

优先级使用的三个原则：

1. Java优先级1-10对应操作系统优先级（具体映射因OS而异）
2. 高优先级只是增加被调度的概率，不保证绝对顺序
3. 过度依赖优先级可能导致线程饥饿（慎用！）

4.2 join()的同步控制艺术

java复制Thread t1 = new Thread(() -> {
    sleep(1);
    r = 10;
});
t1.start();
t1.join(); // 同步点
log.debug("结果:{}", r); // 保证看到r=10

join()的四个使用要点：

1. 实现线程间顺序控制
2. 可设置超时时间（避免永久等待）
3. 会释放线程持有的锁
4. 底层通过wait/notify机制实现

生产案例：在订单处理系统中，支付线程必须等待库存锁定线程完成后才能执行，这种场景就适合使用join()。

5. 守护线程与LockSupport实战

5.1 守护线程的正确打开方式

java复制Thread daemon = new Thread(() -> {
    while(true) {
        // 清理工作...
    }
});
daemon.setDaemon(true); // 必须在线程启动前设置
daemon.start();

守护线程的三大特性：

1. 随JVM退出而终止（不保证finally块执行）
2. 适合执行辅助性工作（如GC、日志清理）
3. 禁止在守护线程中访问关键系统资源

5.2 LockSupport的灵活控制

java复制Thread t1 = new Thread(() -> {
    LockSupport.park(); // 暂停
    log.debug("继续执行");
});
t1.start();
LockSupport.unpark(t1); // 恢复

与wait/notify对比优势：

1. 不需要先获取锁
2. 更精确控制单个线程
3. unpark可以先于park调用（不会死锁）

避坑指南：

• park()会响应中断，但不会清除中断状态
• 连续多次unpark()效果等同于一次
• 每个线程有且只有一个许可（permit）

6. 线程状态转换全景图

通过上述API的组合使用，Java线程会在不同状态间转换：

code复制NEW → RUNNABLE ↔ RUNNING
RUNNING → BLOCKED (同步锁)
RUNNING → WAITING (wait/join)
RUNNING → TIMED_WAITING (sleep/parkNanos)
RUNNING → TERMINATED

状态监测技巧：

java复制Thread.getState(); // 获取当前状态
jstack <pid>      // 查看所有线程状态（生产环境常用）

在实际高并发系统中，合理运用这些线程控制方法，可以构建出既高效又稳定的多线程架构。建议根据具体业务场景选择最适合的API组合，并通过压力测试验证效果。