线程基础详解

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 飞翔科技薪酬计算系统 — 多线程分片处理员工工资
 * 
 * 场景：1000 名员工，分 5 个线程并行计算，最后汇总
 */
public class SalaryCalculator {

    // 员工实体
    static class Employee {
        int id;
        String name;
        double baseSalary;   // 基本工资
        double performance;  // 绩效
        double overtime;     // 加班费
        double total;        // 合计

        public Employee(int id, String name, double baseSalary) {
            this.id = id;
            this.name = name;
            this.baseSalary = baseSalary;
        }

        public void calculate() {
            // 模拟计算逻辑：绩效 = 基本工资 * 随机系数(0.8~1.5)
            this.performance = baseSalary * (0.8 + Math.random() * 0.7);
            // 加班费 = 基本工资 * 0.3 * 随机
            this.overtime = baseSalary * 0.3 * Math.random();
            this.total = baseSalary + performance + overtime;
            // 模拟计算耗时
            try { Thread.sleep(1); } catch (InterruptedException e) { }
        }

        @Override
        public String toString() {
            return String.format("员工[%d] %s: 基本=%.0f, 绩效=%.0f, 加班=%.0f, 合计=%.0f",
                    id, name, baseSalary, performance, overtime, total);
        }
    }

    // 工资计算线程 — 继承 Thread
    static class SalaryThread extends Thread {
        private final List<Employee> employees;
        private final int threadId;

        public SalaryThread(List<Employee> employees, int threadId) {
            this.employees = employees;
            this.threadId = threadId;
        }

        @Override
        public void run() {
            System.out.printf("[线程-%d] 开始处理 %d 名员工的工资...\n",
                    threadId, employees.size());
            long start = System.currentTimeMillis();
            for (Employee emp : employees) {
                emp.calculate();
            }
            long end = System.currentTimeMillis();
            System.out.printf("[线程-%d] 处理完成，耗时: %d ms\n",
                    threadId, (end - start));
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 1. 生成 1000 名员工数据
        List<Employee> allEmployees = new ArrayList<>();
        String[] names = {"张伟", "李娜", "王芳", "赵强", "刘洋", "陈静", "杨帆", "黄莉",
                          "周明", "吴秀", "徐涛", "孙华", "马良", "朱峰", "胡波", "林雨",
                          "何雪", "郭瑞", "高洁", "罗平"};
        Random random = new Random();
        for (int i = 0; i < 200; i++) {
            String name = names[i % names.length] + (i + 1);
            double base = 5000 + random.nextInt(15000); // 5k~20k 基本工资
            allEmployees.add(new Employee(i + 1, name, base));
        }

        System.out.println("========== 飞翔科技薪酬计算系统 (多线程版) ==========");
        System.out.println("总员工数: " + allEmployees.size());
        System.out.println();

        // 2. 分片：分成 5 个线程
        int threadCount = 5;
        int chunkSize = allEmployees.size() / threadCount;
        SalaryThread[] threads = new SalaryThread[threadCount];

        long totalStart = System.currentTimeMillis();

        // 3. 创建并启动线程
        for (int i = 0; i < threadCount; i++) {
            int fromIndex = i * chunkSize;
            int toIndex = (i == threadCount - 1) ? allEmployees.size() : (i + 1) * chunkSize;
            List<Employee> chunk = allEmployees.subList(fromIndex, toIndex);
            threads[i] = new SalaryThread(chunk, i + 1);
            threads[i].start();  // ★ 注意：调用 start() 而不是 run()
        }

        // 4. join() — 等待所有线程完成
        for (int i = 0; i < threadCount; i++) {
            threads[i].join();  // 主线程阻塞，等待子线程 i 完成
        }

        long totalEnd = System.currentTimeMillis();

        // 5. 汇总结果
        double grandTotal = 0;
        for (Employee emp : allEmployees) {
            grandTotal += emp.total;
        }

        System.out.println("\n========== 汇总结果 ==========");
        System.out.printf("应发工资总额: %.2f 元\n", grandTotal);
        System.out.printf("总耗时: %d ms\n", (totalEnd - totalStart));

        // 打印前 5 个员工明细
        System.out.println("\n--- 部分员工工资明细(前5名) ---");
        for (int i = 0; i < 5; i++) {
            System.out.println(allEmployees.get(i));
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 飞翔科技客服工单处理系统 — 多线程 + interrupt 优雅停止
 */
public class CustomerServiceSystem {

    // 工单计数器（线程安全）
    static final AtomicInteger ticketCounter = new AtomicInteger(0);
    // 全局运行标志
    static volatile boolean systemRunning = true;

    // 客服线程 — 实现 Runnable（推荐方式）
    static class CustomerServiceAgent implements Runnable {
        private final String agentName;

        public CustomerServiceAgent(String agentName) {
            this.agentName = agentName;
        }

        @Override
        public void run() {
            System.out.printf("[%s] 上线，开始处理工单...\n", agentName);

            while (systemRunning && !Thread.currentThread().isInterrupted()) {
                // 取出一个工单
                int ticketId = ticketCounter.incrementAndGet();
                System.out.printf("[%s] 正在处理工单 #%d\n", agentName, ticketId);

                // 模拟处理耗时
                try {
                    Thread.sleep(500); // 模拟处理 500ms
                } catch (InterruptedException e) {
                    // ★ interrupt 捕获：sleep 被中断
                    System.out.printf("[%s] 收到中断信号(工单 #%d 处理中)，准备下线...\n",
                            agentName, ticketId);
                    // 恢复中断标志（因为 catch 会清除标志）
                    Thread.currentThread().interrupt();
                    break;
                }

                System.out.printf("[%s] 工单 #%d 处理完成 ✓\n", agentName, ticketId);
            }

            System.out.printf("[%s] 已下线，共处理工单。\n", agentName);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("========== 飞翔科技客服工单系统 ==========\n");

        // 创建 3 个客服线程
        String[] agentNames = {"大翔", "白歌", "小崔"};
        Thread[] agents = new Thread[agentNames.length];

        for (int i = 0; i < agentNames.length; i++) {
            agents[i] = new Thread(
                    new CustomerServiceAgent(agentNames[i]),
                    "客服-" + agentNames[i]
            );
            agents[i].start();
        }

        // 主线程让系统运行 3 秒，然后发起中断
        System.out.println("[系统] 客服系统运行中...\n");
        Thread.sleep(3000);

        System.out.println("\n[系统] 下班时间到！通知所有客服下线...\n");

        // ★ 第一步：设置全局标志
        systemRunning = false;

        // ★ 第二步：中断所有客服线程（处理那些正在 sleep 的线程）
        for (Thread agent : agents) {
            agent.interrupt();
        }

        // ★ 第三步：等待所有客服线程完成
        for (Thread agent : agents) {
            agent.join(2000); // 最多等 2 秒
        }

        System.out.println("\n[系统] 所有客服已下线。今天处理了 " 
                + ticketCounter.get() + " 个工单。");
    }
}

// ✗ 错误：直接调用 run() — 不会创建新线程！
Thread t = new Thread(() -> System.out.println("新线程"));
t.run();   // 在 main 线程执行，输出 "新线程"，但没有并发
System.out.println("main 继续");  // 会在 run() 执行完才输出

// ✓ 正确：调用 start() — 创建新线程
Thread t2 = new Thread(() -> System.out.println("新线程"));
t2.start(); // 新线程异步执行
System.out.println("main 继续");  // 可能先于或后于 "新线程" 输出 — 这才是并发

// ✗ 错误：线程自己 join 自己 — 永远等待
Thread t = new Thread(() -> {
    try {
        Thread.currentThread().join(); // ★ 线程等待自身结束 → 死锁！
    } catch (InterruptedException e) { }
});
t.start();

// ✗ 错误：join() 顺序不当 — 两个线程互相等待
Thread t1 = new Thread(() -> {
    try { t2.join(); } catch (InterruptedException e) { } // t1 等 t2
});
Thread t2 = new Thread(() -> {
    try { t1.join(); } catch (InterruptedException e) { } // t2 等 t1
});
t1.start(); t2.start();
// t1 等 t2 结束，t2 等 t1 结束 → 死锁！

// ✓ 正确：join() 用于父线程等待子线程
Thread worker = new Thread(() -> { /* 耗时任务 */ });
worker.start();
worker.join();  // 父线程等待 worker 完成
System.out.println("worker 已完成");

// ✗ 错误：catch InterruptedException 后不恢复中断标志
public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // ★ 吞掉了中断！循环会继续执行
            System.out.println("被中断了...但是我还继续跑");  // 没有 break，没有恢复标志
        }
    }
}

// ✓ 正确方式一：捕获后 break
public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            break;  // 直接退出循环
        }
    }
}

// ✓ 正确方式二：恢复中断标志
public void run() {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // ★ 恢复标志，下次循环判断退出
        }
    }
}

// ✗ 误解：以为 sleep() 会释放锁
synchronized (lock) {
    Thread.sleep(5000); // ★ sleep 期间仍然持有 lock 的监视器锁！
    // 其他线程在这 5 秒内无法进入该 synchronized 块
}

// ✓ 如果需要释放锁等待，使用 wait()
synchronized (lock) {
    lock.wait(5000); // ★ wait 会释放锁，其他线程可以获取 lock
}

// interrupt() — 实例方法，设置目标线程的中断标志位
thread.interrupt(); // 如果线程在 sleep/wait/join 中，会抛出 InterruptedException

// interrupted() — 静态方法，检测当前线程的中断状态并清除标志位
boolean wasInterrupted = Thread.interrupted(); // ★ 返回后标志位被清除

// isInterrupted() — 实例方法，检测目标线程的中断状态，不清除标志位
boolean isInterrupted = thread.isInterrupted(); // ★ 标志位不变

// 线程创建方式 1：继承 Thread
class MyThread extends Thread {
    @Override public void run() { /* 任务 */ }
}
new MyThread().start();

// 线程创建方式 2：实现 Runnable（推荐）
new Thread(() -> { /* 任务 */ }, "线程名").start();

// 线程创建方式 3：Callable + FutureTask（有返回值）
FutureTask<String> task = new FutureTask<>(() -> "结果");
new Thread(task).start();
String result = task.get(); // 阻塞等待

// 线程基本操作
Thread.sleep(1000);           // 当前线程休眠 1 秒
thread.join();                // 等待 thread 线程终止
thread.join(5000);            // 最多等 5 秒
Thread.yield();               // 提示调度器让出 CPU
thread.interrupt();           // 中断目标线程
thread.setDaemon(true);       // 设为守护线程（必须在 start 前）
thread.setPriority(Thread.MAX_PRIORITY); // 设置优先级 1~10

// 线程状态查询
Thread.State state = thread.getState();
thread.isAlive();             // 线程是否存活
thread.isInterrupted();       // 是否被中断（不清除标志）
Thread.interrupted();         // 当前线程是否被中断（清除标志）

// UncaughtExceptionHandler — 处理未捕获异常
thread.setUncaughtExceptionHandler((t, e) -> {
    System.err.println("线程 " + t.getName() + " 异常: " + e.getMessage());
});