JDK8 中线程实现方法与底层逻辑深度解析

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // 启动线程
    }
}

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable执行: " + Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable执行结果: " + Thread.currentThread().getName();
    }
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new MyCallable());
        System.out.println(future.get());  // 获取返回值
        executor.shutdown();
    }
}

// 1. 固定大小线程池
ExecutorService fixedPool = Executors.newFixedThreadPool(5);
// 2. 缓存线程池
ExecutorService cachedPool = Executors.newCachedThreadPool();
// 3. 单线程池
ExecutorService singlePool = Executors.newSingleThreadExecutor();
// 4. 调度线程池
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3);

public ThreadPoolExecutor(
    int corePoolSize,      // 核心线程数
    int maximumPoolSize,   // 最大线程数
    long keepAliveTime,    // 空闲线程存活时间
    TimeUnit unit,         // 时间单位
    BlockingQueue<Runnable> workQueue,  // 工作队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

提交任务 → 核心线程是否满？ → 否 → 创建核心线程执行
                    ↓是
           工作队列是否满？ → 否 → 加入队列等待
                    ↓是
           最大线程是否满？ → 否 → 创建临时线程
                    ↓是
                   执行拒绝策略

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("异步执行: " + Thread.currentThread().getName());
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    return "异步计算结果";
});

Java Thread → JVM Thread → pthread（Linux）/ Windows Thread → CPU 调度

public enum State {
    NEW,           // 新建
    RUNNABLE,      // 可运行（包括就绪和运行）
    BLOCKED,       // 阻塞（等待监视器锁）
    WAITING,       // 等待（无限期等待）
    TIMED_WAITING, // 超时等待
    TERMINATED     // 终止
}

NEW --start()--> RUNNABLE
RUNNABLE --获取锁失败--> BLOCKED
RUNNABLE --wait()/join()--> WAITING
RUNNABLE --sleep(n)/wait(n)--> TIMED_WAITING
各种状态 --执行完毕/异常--> TERMINATED