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

    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.setName("worker-1");       // 线上排查必备：给线程起个有意义的名字
        t.start();                   // 注意是 start() 而不是 run()
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        // 任务是任务，线程是线程：同一个 Runnable 可以被多个线程执行
        Runnable task = () -> System.out.println(Thread.currentThread().getName() + " 执行任务");
        new Thread(task, "order-service-1").start();
        new Thread(task, "order-service-2").start();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Callable 允许返回结果、允许抛出异常
        Callable<Integer> sum = () -> {
            int s = 0;
            for (int i = 1; i <= 100; i++) {
                s += i;
            }
            return s;
        };

        FutureTask<Integer> future = new FutureTask<>(sum);
        new Thread(future, "calc-thread").start();

        // get() 会阻塞直到任务完成，也可以 get(1, TimeUnit.SECONDS) 设置超时
        Integer result = future.get();
        System.out.println("1+2+...+100 = " + result);
    }
}

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) throws Exception {
        // 推荐手动创建：明确队列长度与拒绝策略，避免 Executors.newFixedThreadPool 的无界队列风险
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                4,                                  // 核心线程数
                8,                                  // 最大线程数
                30, TimeUnit.SECONDS,               // 非核心线程空闲存活时间
                new ArrayBlockingQueue<>(200),       // 有界队列，防止 OOM
                new ThreadFactory() {                // 自定义线程名，出问题时看堆栈一目了然
                    private int i = 0;
                    @Override
                    public Thread newThread(Runnable r) {
                        return new Thread(r, "biz-pool-" + (++i));
                    }
                },
                new ThreadPoolExecutor.CallerRunsPolicy()); // 让提交任务的线程自己跑，天然限流

        Future<Integer> f = pool.submit(() -> 42);
        System.out.println("结果 = " + f.get());
        pool.shutdown();  // 平滑关闭：不再接收新任务，执行完队列中存量任务
    }
}

public class StartVsRunDemo {
    public static void main(String[] args) {
        Runnable task = () -> System.out.println("执行线程：" + Thread.currentThread().getName());

        System.out.println("当前线程：" + Thread.currentThread().getName());

        new Thread(task, "A").run();    // 仍在 main 线程执行
        new Thread(task, "B").start();  // 新开线程 B 执行
    }
}
// 输出：
// 当前线程：main
// 执行线程：main   <- run() 没有开启新线程，仍由 main 执行
// 执行线程：B     <- start() 才真正启动新线程 B

public class ThreadStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        Thread t = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();          // 进入 WAITING（会先释放 lock）
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "state-thread");

        System.out.println("1. " + t.getState());   // NEW
        t.start();
        Thread.sleep(100);
        System.out.println("2. " + t.getState());   // WAITING
        synchronized (lock) {
            lock.notifyAll();                        // 唤醒后需重新竞争 Monitor
        }
        t.join();
        System.out.println("3. " + t.getState());   // TERMINATED
    }
}

public class StopThreadDemo {
    static class Worker implements Runnable {
        // volatile 保证标志位的可见性（详见第五节）
        private volatile boolean cancelled = false;

        @Override
        public void run() {
            long num = 0;
            while (!cancelled && !Thread.currentThread().isInterrupted()) {
                num++;
                try {
                    // 模拟一段可中断的阻塞工作
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    // sleep 被中断时会清除中断标志，必须重新设置，否则外层循环感知不到
                    Thread.currentThread().interrupt();
                    System.out.println("在阻塞中被中断，准备退出");
                }
            }
            System.out.println("线程安全退出，累计处理 " + num + " 次");
        }

        public void cancel() {
            cancelled = true;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Worker worker = new Worker();
        Thread t = new Thread(worker, "cleanup-worker");
        t.start();
        Thread.sleep(1000);
        t.interrupt();   // 协作式中断：请求而非强制
        worker.cancel(); // 双保险：volatile 标志位
        t.join();
    }
}

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++;   // 字节码层面：getfield -> iconst_1/iadd -> putfield，三步可被打断
    }

    public static void main(String[] args) throws InterruptedException {
        UnsafeCounter counter = new UnsafeCounter();
        Runnable task = () -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task, "add-1");
        Thread t2 = new Thread(task, "add-2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // 期望 20000，实际大概率小于 20000，且每次运行结果都不同
        System.out.println("实际结果 = " + counter.count);
    }
}

public class DCLSingleton {
    // 关键：必须用 volatile 禁止 ②③ 重排序；去掉 volatile 在极端情况下会拿到半初始化对象
    private static volatile DCLSingleton instance;

    private int value = 42;   // 用于验证对象是否初始化完成

    private DCLSingleton() {}

    public static DCLSingleton getInstance() {
        if (instance == null) {                  // 第一次检查：避免每次都加锁，提升性能
            synchronized (DCLSingleton.class) {
                if (instance == null) {          // 第二次检查：防止多个线程重复创建
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }

    public int getValue() {
        return value;
    }
}

public class VolatileNotAtomic {
    private volatile int count = 0;   // 可见性有了，原子性依然没有

    public void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileNotAtomic c = new VolatileNotAtomic();
        Thread t1 = new Thread(() -> { for (int i = 0; i < 10000; i++) c.increment(); });
        Thread t2 = new Thread(() -> { for (int i = 0; i < 10000; i++) c.increment(); });
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("volatile 也不能保证结果 = " + c.count);  // 依然大概率 < 20000
    }
}

public class SynchronizedUsage {
    private final Object lock = new Object();  // 专用锁对象，避免外部代码锁住 this 造成干扰
    private static int staticCount = 0;
    private int instanceCount = 0;

    public synchronized void addInstance() {   // 锁的是 this
        instanceCount++;
    }

    public static synchronized void addStatic() {  // 锁的是 SynchronizedUsage.class
        staticCount++;
    }

    public void addByBlock() {
        synchronized (lock) {                  // 锁的是 lock，粒度最小，推荐
            instanceCount++;
        }
    }

    public static void main(String[] args) throws Exception {
        SynchronizedUsage o = new SynchronizedUsage();
        Thread t1 = new Thread(o::addInstance, "t1");
        Thread t2 = new Thread(SynchronizedUsage::addStatic, "t2");
        Thread t3 = new Thread(o::addByBlock, "t3");
        t1.start(); t2.start(); t3.start();
        t1.join(); t2.join(); t3.join();
        System.out.println(o.instanceCount + " / " + staticCount);
    }
}

public class ReentrantDemo {
    public synchronized void outer() {
        System.out.println("outer 拿到锁");
        inner();   // 同一个线程再次请求同一把锁（this），直接成功
    }

    public synchronized void inner() {
        System.out.println("inner 再次拿到锁，证明可重入");
    }

    public static void main(String[] args) {
        new ReentrantDemo().outer();
    }
}

public class MonitorBytecode {
    private final Object lock = new Object();

    public void method() {
        synchronized (lock) {
            System.out.println("hello");
        }
    }
}
// javap -v MonitorBytecode 后 method() 的字节码：
//  0: aload_0
//  1: getfield      #3   // Field lock:Ljava/lang/Object;
//  4: dup
//  5: astore_1
//  6: monitorenter       // 进入同步块：尝试获取 lock 的 Monitor
//  7: getstatic     #4   // System.out
// 10: ldc           #5   // String hello
// 12: invokevirtual #6   // println
// 15: aload_1
// 16: monitorexit        // 正常出口释放锁
// 17: goto          25
// 20: astore_2           // 异常处理：保证异常时也能释放锁
// 21: aload_1
// 22: monitorexit        // 异常出口释放锁
// 25: return

public class BankTransfer {
    static class Account {
        private final String name;
        private int balance;
        Account(String name, int balance) { this.name = name; this.balance = balance; }
    }

    // 错误写法：check-then-act，检查与扣款之间可被插入
    static void transferUnsafe(Account from, Account to, int amount) {
        if (from.balance >= amount) {
            from.balance -= amount;
            to.balance += amount;
        }
    }

    // 正确写法：锁定两个账户；注意锁顺序必须稳定，否则就是下一节的死锁
    static void transferSafe(Account from, Account to, int amount) {
        Account first  = from.name.compareTo(to.name) < 0 ? from : to;  // 固定加锁顺序
        Account second = first == from ? to : from;
        synchronized (first) {
            synchronized (second) {
                if (from.balance >= amount) {
                    from.balance -= amount;
                    to.balance += amount;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Account a = new Account("A", 1000);
        Account b = new Account("B", 1000);
        Runnable task = () -> {
            for (int i = 0; i < 2000; i++) {
                transferSafe(a, b, 1);
                transferSafe(b, a, 1);
            }
        };
        Thread t1 = new Thread(task); Thread t2 = new Thread(task);
        t1.start(); t2.start(); t1.join(); t2.join();
        // 相互转账总额守恒，结果恒为 2000
        System.out.println("A=" + a.balance + ", B=" + b.balance + ", 总额=" + (a.balance + b.balance));
    }
}

public class DeadlockDemo {
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("t1 拿到 lockA，等待 lockB");
                try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                synchronized (lockB) {
                    System.out.println("t1 拿到 lockB");
                }
            }
        }, "deadlock-t1");

        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("t2 拿到 lockB，等待 lockA");
                synchronized (lockA) {
                    System.out.println("t2 拿到 lockA");
                }
            }
        }, "deadlock-t2");

        t1.start();
        t2.start();
        // 程序将永久挂起。排查方式：
        // jps 找到 pid -> jstack -l pid | tail -40
        // 输出中会出现 "Found one Java-level deadlock" 并列出两个线程互相持有的锁
    }
}

import java.util.LinkedList;
import java.util.Queue;

public class WaitNotifyProducerConsumer {
    private static final int CAPACITY = 5;
    private final Queue<Integer> queue = new LinkedList<>();
    private final Object lock = new Object();

    static class Producer implements Runnable {
        private final WaitNotifyProducerConsumer pc;
        Producer(WaitNotifyProducerConsumer pc) { this.pc = pc; }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (pc.lock) {
                    // 关键点一：必须用 while 而非 if，防止虚假唤醒
                    while (pc.queue.size() == CAPACITY) {
                        try {
                            pc.lock.wait();   // 关键点二：wait 会释放 lock，sleep 不会
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    pc.queue.offer(i);
                    System.out.println(Thread.currentThread().getName() + " 生产 " + i + "，队列=" + pc.queue);
                    pc.lock.notifyAll();  // 关键点三：用 notifyAll，避免唤醒同类线程导致"信号丢失"
                }
            }
        }
    }

    static class Consumer implements Runnable {
        private final WaitNotifyProducerConsumer pc;
        Consumer(WaitNotifyProducerConsumer pc) { this.pc = pc; }

        @Override
        public void run() {
            while (true) {
                synchronized (pc.lock) {
                    while (pc.queue.isEmpty()) {
                        try {
                            pc.lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    System.out.println(Thread.currentThread().getName() + " 消费 " + pc.queue.poll() + "，队列=" + pc.queue);
                    pc.lock.notifyAll();
                }
            }
        }
    }

    public static void main(String[] args) {
        WaitNotifyProducerConsumer pc = new WaitNotifyProducerConsumer();
        new Thread(new Producer(pc), "producer-1").start();
        new Thread(new Consumer(pc), "consumer-1").start();
        new Thread(new Consumer(pc), "consumer-2").start();
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueProducerConsumer {
    public static void main(String[] args) {
        // 阻塞队列把"等待/通知"的脏活全封装好了：满了阻塞生产者，空了阻塞消费者
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);

        Runnable producer = () -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);   // 队列满时阻塞
                    System.out.println(Thread.currentThread().getName() + " 生产 " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        Runnable consumer = () -> {
            try {
                while (true) {
                    Integer v = queue.take();   // 队列空时阻塞
                    System.out.println(Thread.currentThread().getName() + " 消费 " + v);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        new Thread(producer, "producer-1").start();
        new Thread(producer, "producer-2").start();
        new Thread(consumer, "consumer-1").start();
        new Thread(consumer, "consumer-2").start();
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionProducerConsumer {
    private final ReentrantLock lock = new ReentrantLock(true);  // 公平锁
    private final Condition notFull  = lock.newCondition();      // 独立的"不满"条件队列
    private final Condition notEmpty = lock.newCondition();      // 独立的"不空"条件队列
    private final Object[] items = new Object[5];
    private int count, putIndex, takeIndex;

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();       // 只在 notFull 上等待，signal 时能精准唤醒生产者
            }
            items[putIndex] = x;
            if (++putIndex == items.length) putIndex = 0;
            count++;
            System.out.println(Thread.currentThread().getName() + " 生产 " + x);
            notEmpty.signal();         // 只唤醒一个消费者，开销小于 notifyAll
        } finally {
            lock.unlock();             // 必须放在 finally 中
        }
    }

    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();
            }
            Object x = items[takeIndex];
            if (++takeIndex == items.length) takeIndex = 0;
            count--;
            System.out.println(Thread.currentThread().getName() + " 消费 " + x);
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ConditionProducerConsumer pc = new ConditionProducerConsumer();
        for (int i = 0; i < 2; i++) {
            final int id = i;
            new Thread(() -> {
                try { for (int j = 0; j < 5; j++) pc.put(id + "-" + j); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }, "producer-" + i).start();
        }
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                try { while (true) pc.take(); }
                catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }, "consumer-" + i).start();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.CountDownLatch;

public class CounterBenchmark {
    static final int THREADS = 20;
    static final int TIMES = 500_000;

    // 方案一：synchronized，正确性由互斥保证
    static class SyncCounter {
        private int value = 0;
        synchronized void inc() { value++; }
        int get() { return value; }
    }

    // 方案二：AtomicInteger，基于 CAS 自旋，无锁
    static class AtomicCounter {
        private final AtomicInteger value = new AtomicInteger();
        void inc() { value.incrementAndGet(); }
        int get() { return value.get(); }
    }

    // 方案三：LongAdder，热点分散到多个 Cell，高并发下最优
    static class AdderCounter {
        private final LongAdder adder = new LongAdder();
        void inc() { adder.increment(); }
        int get() { return adder.intValue(); }   // 注意：sum() 非原子快照
    }

    // 方案四：锁分段，把一把大锁拆成 N 把小锁，降低冲突概率
    static class SegmentCounter {
        private static final int N = 16;
        private final Object[] locks = new Object[N];
        private final int[] values = new int[N];
        SegmentCounter() { for (int i = 0; i < N; i++) locks[i] = new Object(); }
        void inc() {
            int idx = Thread.currentThread().hashCode() & (N - 1);
            synchronized (locks[idx]) { values[idx]++; }
        }
        int get() {
            int sum = 0;
            for (int i = 0; i < N; i++) synchronized (locks[i]) { sum += values[i]; }
            return sum;
        }
    }

    interface Counter { void inc(); int get(); }

    static long run(Counter c) throws InterruptedException {
        CountDownLatch start = new CountDownLatch(1);
        CountDownLatch done = new CountDownLatch(THREADS);
        Thread[] ts = new Thread[THREADS];
        for (int i = 0; i < THREADS; i++) {
            ts[i] = new Thread(() -> {
                try {
                    start.await();                 // 让所有线程同时起跑，减少计时误差
                    for (int j = 0; j < TIMES; j++) c.inc();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    done.countDown();
                }
            }, "bench-" + i);
            ts[i].start();
        }
        long begin = System.nanoTime();
        start.countDown();
        done.await();
        long cost = System.nanoTime() - begin;
        System.out.println(c.getClass().getSimpleName() + " 结果=" + c.get()
                + "，耗时=" + cost / 1_000_000 + "ms");
        return cost;
    }

    public static void main(String[] args) throws InterruptedException {
        run(new SyncCounter());
        run(new AtomicCounter());
        run(new AdderCounter());
        run(new SegmentCounter());
    }
}

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class PrintABC {
    private static final int TIMES = 10;
    private final ReentrantLock lock = new ReentrantLock();
    // 三个条件队列，分别对应打印 A/B/C 的线程，实现精准唤醒
    private final Condition ca = lock.newCondition();
    private final Condition cb = lock.newCondition();
    private final Condition cc = lock.newCondition();
    private int flag = 0;   // 0->A, 1->B, 2->C

    public void printA() throws InterruptedException { print("A", 0, ca, cb); }
    public void printB() throws InterruptedException { print("B", 1, cb, cc); }
    public void printC() throws InterruptedException { print("C", 2, cc, ca); }

    private void print(String ch, int target, Condition self, Condition next) throws InterruptedException {
        for (int i = 0; i < TIMES; i++) {
            lock.lock();
            try {
                while (flag != target) {   // while 防止虚假唤醒
                    self.await();
                }
                System.out.print(ch);
                flag = (target + 1) % 3;   // 轮转状态
                next.signal();             // 只唤醒下一个该打印的线程
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        PrintABC p = new PrintABC();
        new Thread(() -> { try { p.printA(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "T-A").start();
        new Thread(() -> { try { p.printB(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "T-B").start();
        new Thread(() -> { try { p.printC(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "T-C").start();
        // 输出：ABCABCABCABCABCABCABCABCABCABC
    }
}