线程创建五种方式：Thread、Runnable、Callable、线程池、CompletableFuture

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程运行中: " + Thread.currentThread().getName());
    }
}

// 启动线程
MyThread t = new MyThread();
t.start();  // 注意：不是 t.run()！run() 只是普通方法调用

public class StartVsRun {
    public static void main(String[] args) {
        Thread t = new Thread(() ->
            System.out.println("干活的是: " + Thread.currentThread().getName()));

        t.run();    // 输出"干活的是: main" —— 主线程自己把活干了
        t.start();  // 输出"干活的是: Thread-0" —— 真的新开了一条线程
    }
}

@Override
public void run() {
    if (target != null) {   // target 就是构造时传入的 Runnable
        target.run();
    }
}

public class MyTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable 任务运行中: " + Thread.currentThread().getName());
    }
}

// 创建并启动线程
Thread t = new Thread(new MyTask());
t.start();

// Runnable 是函数式接口（@FunctionalInterface），JDK 8+ 可以写 Lambda
Thread t2 = new Thread(() -> System.out.println("Lambda 写法"));
t2.start();

import java.util.concurrent.*;

// 1. 实现 Callable，指定返回类型；call() 可以 throws Exception
public class CalcTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        Thread.sleep(2000);   // 模拟耗时计算，受检异常直接往外抛
        return 42;
    }
}

// 2. 用 FutureTask 包装 Callable（FutureTask 本身实现了 Runnable）
FutureTask<Integer> futureTask = new FutureTask<>(new CalcTask());

// 3. 传给 Thread 并启动（Thread 的构造器只收 Runnable，而 FutureTask 正是 Runnable）
new Thread(futureTask).start();

// 4. 阻塞等待结果
Integer result = futureTask.get();   // 阻塞当前线程，直到计算完成
System.out.println("计算结果: " + result);

Future<String> future = executor.submit(() -> doRemoteCall());

try {
    // 限时等待：最多等 3 秒，超时立刻抛 TimeoutException，别干等
    String result = future.get(3, TimeUnit.SECONDS);
} catch (InterruptedException e) {
    // ① 当前线程在等待时被中断
} catch (ExecutionException e) {
    // ② 任务内部抛了异常，包在 ExecutionException 里（getCause() 才是真异常）
} catch (TimeoutException e) {
    // ③ 超时了 —— 通常要配合 future.cancel(true) 把任务取消掉
}

import java.util.concurrent.*;

// 不要用 Executors 工厂（原因见第 8 站），用 ThreadPoolExecutor 手动建
ThreadPoolExecutor pool = new ThreadPoolExecutor(
    2,                            // corePoolSize    核心线程数
    4,                            // maximumPoolSize 最大线程数
    60L, TimeUnit.SECONDS,       // keepAliveTime   非核心线程空闲存活时间
    new LinkedBlockingQueue<>(100), // workQueue        任务队列（生产建议有界）
    new NamedThreadFactory("biz-pool"), // threadFactory  线程工厂（命名，见第 9 站）
    new ThreadPoolExecutor.CallerRunsPolicy()  // handler         拒绝策略
);

// execute：提交 Runnable，没有返回值
pool.execute(() -> System.out.println("Runnable 任务"));

// submit：提交 Callable/Runnable，返回 Future 可以拿结果、拿异常
Future<String> future = pool.submit(() -> {
    Thread.sleep(1000);
    return "线程池返回的结果";
});
System.out.println(future.get());

// 用完关闭（生产里通常是应用关闭钩子里做两阶段优雅关闭）
pool.shutdown();

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

public class NamedThreadFactory implements ThreadFactory {
    private final AtomicInteger seq = new AtomicInteger(1);
    private final String prefix;

    public NamedThreadFactory(String prefix) {
        this.prefix = prefix;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, prefix + "-" + seq.getAndIncrement());
        t.setDaemon(false);       // 按业务需要设置是否守护线程
        t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

// 使用：线程池的第五个参数传入
ThreadPoolExecutor pool = new ThreadPoolExecutor(
    2, 4, 60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),
    new NamedThreadFactory("order-push"),   // 线程名: order-push-1, order-push-2...
    new ThreadPoolExecutor.CallerRunsPolicy()
);

import com.google.common.util.concurrent.ThreadFactoryBuilder;

ThreadFactory named = new ThreadFactoryBuilder()
    .setNameFormat("order-push-%d")   // %d 会自动替换为序号
    .setDaemon(false)
    .build();

import java.util.concurrent.*;

// 1. runAsync：没有返回值，干完拉倒（默认在 ForkJoinPool.commonPool 执行）
CompletableFuture<Void> f1 = CompletableFuture.runAsync(() -> {
    // 异步刷缓存、写日志之类，不需要结果
    cache.refresh("hot-key");
});

// 2. supplyAsync：有返回值，像 Callable 一样能拿到结果
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> {
    try { Thread.sleep(1000); } catch (InterruptedException e) {}
    return "查询完成";
});

// 3. 拿结果：join() 和 get() 类似，但抛的是非受检的 CompletionException
System.out.println(f2.join());

CompletableFuture.supplyAsync(() -> "查询完成")
    // 拿到结果后继续转换（有参有返回）
    .thenApply(result -> result + "，已处理")
    // 消费结果，不再返回（有参无返回）
    .thenAccept(finalResult -> System.out.println(finalResult))
    // 异常兜底：任何一环抛异常都会走到这里
    .exceptionally(ex -> { System.out.println("出错了: " + ex); return null; });

// 组合两个独立的异步任务
CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> cf2 = CompletableFuture.supplyAsync(() -> 20);
cf1.thenCombine(cf2, (a, b) -> a + b)
   .thenAccept(sum -> System.out.println("合计: " + sum));  // 30

ThreadPoolExecutor pool = buildPool("detail-query");   // 自定义线程池

// 三个查询并行提交，拿到三个 Future
Future<BigDecimal> priceF = pool.submit(() -> queryPrice(id));
Future<Integer>  stockF = pool.submit(() -> queryStock(id));
Future<String>  reviewF = pool.submit(() -> queryReview(id));

// 逐个限时取结果：任何一个超过 1 秒都不等它
BigDecimal price  = priceF.get(1, TimeUnit.SECONDS);
Integer   stock  = stockF.get(1, TimeUnit.SECONDS);
String     review = reviewF.get(1, TimeUnit.SECONDS);
// 问题：三个 get 是串行阻塞的！price 等 1 秒、stock 又等 1 秒……最坏总耗时 3 秒相加

// pool：同上一段的自定义线程池（生产必须传，别用 commonPool）
CompletableFuture<BigDecimal> priceF = CompletableFuture.supplyAsync(() -> queryPrice(id), pool);
CompletableFuture<Integer>  stockF = CompletableFuture.supplyAsync(() -> queryStock(id), pool);
CompletableFuture<String>  reviewF = CompletableFuture.supplyAsync(() -> queryReview(id), pool);

// 三个任务并发执行，全部完成后触发回调（真正的并行等待）
CompletableFuture.allOf(priceF, stockF, reviewF)
    .thenApply(v -> "价格 " + priceF.join() + "，库存 " + stockF.join()
                 + "，评价 " + reviewF.join())
    .orTimeout(3, TimeUnit.SECONDS)   // 整体超时 3 秒，到点抛 TimeoutException
    .exceptionally(ex -> "查询超时，返回兜底数据")
    .thenAccept(System.out::println);

// 方式一：工厂方法，等价于"每条虚拟线程跑一个 Runnable"
Thread vt = Thread.ofVirtual().name("vt-1").start(() -> doWork());

// 方式二：配合 Executors 新工厂（虚拟线程版"线程池"，几乎无限量）
try (ExecutorService pool = Executors.newVirtualThreadPerTaskExecutor()) {
    pool.submit(() -> doWork());
    pool.submit(() -> doWork());
}   // try-with-resources 关闭时会等所有任务结束（JDK 19+ 支持）