public class ThreadDemo {
    // 方式1：继承 Thread
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Thread 子类: " + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 方式2：实现 Runnable（推荐）
        Thread t1 = new Thread(() -> {
            System.out.println("Runnable: " + Thread.currentThread().getName());
        }, "worker-1");

        // 方式3：实现 Callable（有返回值）
        var executor = java.util.concurrent.Executors.newFixedThreadPool(2);
        var future = executor.submit(() -> {
            Thread.sleep(1000);
            return 42;
        });
        System.out.println("Callable 结果: " + future.get());  // 阻塞等待

        new MyThread().start();
        t1.start();
        t1.join();  // 等待线程结束

        executor.shutdown();
    }
}

public class SyncDemo {
    private int count = 0;
    private final Object lock = new Object();

    // synchronized 方法
    public synchronized void increment() {
        count++;
    }

    // synchronized 块
    public void decrement() {
        synchronized (lock) {
            count--;
        }
    }

    // ReentrantLock
    private final java.util.concurrent.locks.ReentrantLock reLock =
        new java.util.concurrent.locks.ReentrantLock();

    public void safeIncrement() {
        reLock.lock();
        try {
            count++;
        } finally {
            reLock.unlock();
        }
    }

    // volatile —— 保证可见性（不保证原子性）
    private volatile boolean running = true;

    public void stop() { running = false; }

    public static void main(String[] args) throws InterruptedException {
        SyncDemo demo = new SyncDemo();
        var pool = java.util.concurrent.Executors.newFixedThreadPool(10);

        for (int i = 0; i < 1000; i++) {
            pool.submit(demo::increment);
        }
        pool.shutdown();
        pool.awaitTermination(5, java.util.concurrent.TimeUnit.SECONDS);
        System.out.println("Count: " + demo.count);  // 1000
    }
}

import java.util.concurrent.atomic.*;

public class AtomicDemo {
    private final AtomicInteger counter = new AtomicInteger(0);
    private final AtomicReference<String> ref = new AtomicReference<>("initial");

    public void incrementAndGet() {
        int newVal = counter.incrementAndGet();  // CAS 操作
    }

    public int getAndUpdate() {
        return counter.getAndUpdate(n -> n + 5);  // 函数式更新
    }

    // LongAdder —— 高并发计数（比 AtomicLong 更快）
    private final java.util.concurrent.atomic.LongAdder adder = new java.util.concurrent.atomic.LongAdder();

    public void addCount() {
        adder.increment();
        adder.add(10);
    }

    public long getCount() { return adder.sum(); }
}

import java.util.concurrent.*;

public class ExecutorDemo {
    public static void main(String[] args) throws Exception {
        // 固定大小线程池
        ExecutorService fixed = Executors.newFixedThreadPool(4);

        // 缓存线程池
        ExecutorService cached = Executors.newCachedThreadPool();

        // 单线程池
        ExecutorService single = Executors.newSingleThreadExecutor();

        // 定时线程池
        ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(2);

        // 推荐：自定义 ThreadPoolExecutor
        ThreadPoolExecutor custom = new ThreadPoolExecutor(
            4,                         // 核心线程数
            8,                         // 最大线程数
            60, TimeUnit.SECONDS,      // 空闲线程存活时间
            new LinkedBlockingQueue<>(100),  // 任务队列
            new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
        );

        // 提交任务
        Future<String> future = fixed.submit(() -> {
            Thread.sleep(1000);
            return "完成";
        });
        System.out.println(future.get(5, TimeUnit.SECONDS));

        // 定时任务
        scheduled.scheduleAtFixedRate(() -> {
            System.out.println("定时任务: " + System.currentTimeMillis());
        }, 0, 2, TimeUnit.SECONDS);

        // invokeAll —— 批量执行
        var tasks = List.of(
            () -> { Thread.sleep(500); return "任务1"; },
            () -> { Thread.sleep(300); return "任务2"; },
            () -> { Thread.sleep(400); return "任务3"; }
        );
        var results = fixed.invokeAll(tasks);
        for (var r : results) {
            System.out.println(r.get());
        }

        // 优雅关闭
        fixed.shutdown();
        if (!fixed.awaitTermination(10, TimeUnit.SECONDS)) {
            fixed.shutdownNow();
        }
    }
}

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    public static void main(String[] args) throws Exception {
        // 基本创建
        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
            sleep(500);
            return "Hello";
        });

        // 链式操作
        String result = CompletableFuture.supplyAsync(() -> "Hello")
            .thenApply(s -> s + " World")         // 转换
            .thenApply(String::toUpperCase)       // 再转换
            .thenApply(s -> s + "!")              // 再转换
            .join();                               // 阻塞获取
        System.out.println(result);  // HELLO WORLD!

        // 消费结果（无返回值）
        CompletableFuture.runAsync(() -> System.out.println("异步执行"));

        // 组合多个异步任务
        var userFuture = CompletableFuture.supplyAsync(() -> "用户数据");
        var orderFuture = CompletableFuture.supplyAsync(() -> "订单数据");

        // 等待所有完成
        CompletableFuture.allOf(userFuture, orderFuture).join();
        System.out.println(userFuture.join() + " + " + orderFuture.join());

        // 任意一个完成
        CompletableFuture.anyOf(
            CompletableFuture.supplyAsync(() -> { sleep(1000); return "慢"; }),
            CompletableFuture.supplyAsync(() -> { sleep(100); return "快"; })
        ).thenAccept(r -> System.out.println("最快: " + r));

        // 异常处理
        String fallback = CompletableFuture.supplyAsync(() -> {
            if (true) throw new RuntimeException("失败");
            return "ok";
        }).exceptionally(ex -> "降级数据")   // 异常时返回默认值
          .join();
        System.out.println(fallback);  // 降级数据

        // handle —— 无论成功失败都处理
        CompletableFuture.supplyAsync(() -> "data")
            .handle((data, ex) -> {
                if (ex != null) return "错误: " + ex.getMessage();
                return "成功: " + data;
            })
            .thenAccept(System.out::println);
    }

    static void sleep(long ms) {
        try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }
}

import java.util.concurrent.*;

public class ConcurrentUtils {
    // CountDownLatch —— 倒计数门闩
    static void countDownLatchDemo() throws InterruptedException {
        int taskCount = 3;
        CountDownLatch latch = new CountDownLatch(taskCount);

        for (int i = 0; i < taskCount; i++) {
            final int taskId = i;
            new Thread(() -> {
                try {
                    Thread.sleep((long)(Math.random() * 1000));
                    System.out.println("任务 " + taskId + " 完成");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await();  // 等待所有任务完成
        System.out.println("所有任务已完成");
    }

    // Semaphore —— 信号量（限流）
    static void semaphoreDemo() {
        Semaphore sem = new Semaphore(3);  // 最多3个并发

        for (int i = 0; i < 10; i++) {
            final int id = i;
            new Thread(() -> {
                try {
                    sem.acquire();  // 获取许可
                    System.out.println(id + " 进入（并发: " + (3 - sem.availablePermits()) + "）");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    sem.release();
                }
            }).start();
        }
    }

    // ConcurrentHashMap
    static void concurrentMapDemo() {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("count", 0);

        // 原子操作
        map.compute("count", (k, v) -> v == null ? 1 : v + 1);
        map.merge("count", 1, Integer::sum);
        map.putIfAbsent("new", 1);

        // 批量操作（JDK 8+）
        map.forEach(1, (k, v) -> System.out.println(k + " = " + v));
        long count = map.reduceValues(1, v -> v > 0 ? 1L : 0L, Long::sum);
    }
}