Java 并发

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

// 2. 实现Runnable接口（推荐）
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable: " + Thread.currentThread().getName());
    }
}

// 3. 实现Callable接口（有返回值）
class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Callable result: " + Thread.currentThread().getName();
    }
}

// 4. 使用线程池（最佳实践）
public class ThreadCreationDemo {
    public static void main(String[] args) throws Exception {
        // 方式1：继承Thread
        new MyThread().start();

        // 方式2：实现Runnable
        new Thread(new MyRunnable()).start();

        // 方式3：Callable + FutureTask
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
        new Thread(futureTask).start();
        System.out.println(futureTask.get()); // 获取返回值

        // 方式4：线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.submit(new MyRunnable());
        executor.submit(new MyCallable());
        executor.shutdown();
    }
}

public enum State {
    NEW,          // 新建
    RUNNABLE,     // 可运行（就绪+运行）
    BLOCKED,      // 阻塞
    WAITING,      // 等待
    TIMED_WAITING,// 超时等待
    TERMINATED;   // 终止
}

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

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程开始等待");
                    lock.wait(); // WAITING状态
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        System.out.println("创建后状态: " + thread.getState()); // NEW

        thread.start();
        Thread.sleep(100);
        System.out.println("启动后状态: " + thread.getState()); // WAITING

        synchronized (lock) {
            lock.notify(); // 唤醒线程
        }

        thread.join();
        System.out.println("结束后状态: " + thread.getState()); // TERMINATED
    }
}

public class VolatileDemo {
    private volatile boolean flag = false;
    private int count = 0;

    // 线程1：写操作
    public void writer() {
        count = 42;      // 1. 普通写
        flag = true;     // 2. volatile写
    }

    // 线程2：读操作
    public void reader() {
        if (flag) {      // 3. volatile读
            int value = count; // 4. 普通读，能看到count=42
        }
    }
}

// 1. 状态标志
public class StatusFlag {
    private volatile boolean shutdown = false;

    public void shutdown() {
        shutdown = true; // 写线程
    }

    public void work() {
        while (!shutdown) { // 读线程，能立即看到变化
            // 执行工作
        }
    }
}

// 2. 双重检查锁定（DCL）
public class Singleton {
    private volatile static Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton(); // volatile防止指令重排
                }
            }
        }
        return instance;
    }
}

public class SynchronizedDemo {
    private int count = 0;

    // 1. 偏向锁：只有一个线程访问
    public synchronized void increment() {
        count++; // 第一次访问，获得偏向锁
    }

    // 2. 轻量级锁：少量线程竞争，自旋等待
    public void lightweightLock() {
        synchronized (this) {
            // 多个线程竞争，升级为轻量级锁
            // 通过CAS和自旋获取锁
            count++;
        }
    }

    // 3. 重量级锁：竞争激烈，线程阻塞
    public void heavyweightLock() {
        synchronized (this) {
            try {
                // 竞争激烈时，升级为重量级锁
                // 线程进入阻塞状态，由操作系统调度
                Thread.sleep(100);
                count++;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

// 偏向锁 → 轻量级锁
// 当有第二个线程尝试获取偏向锁时

// 轻量级锁 → 重量级锁
// 当自旋次数超过阈值（默认10次）或自旋线程数超过CPU核数一半时

public class SyncBytecode {
    public synchronized void method1() {
        // 方法级别的synchronized
    }

    public void method2() {
        synchronized (this) {
            // 代码块级别的synchronized
        }
    }
}

// 编译后的字节码：
// method1: ACC_SYNCHRONIZED标志
// method2: monitorenter和monitorexit指令

// 对象头结构（64位JVM）
// Mark Word (64 bits) + Class Pointer (32 bits) + Array Length (32 bits, 数组才有)

// Mark Word在不同锁状态下的存储内容：
// 无锁：hashcode(31) + age(4) + biased_lock(1) + lock(2)
// 偏向锁：thread_id(54) + epoch(2) + age(4) + biased_lock(1) + lock(2)
// 轻量级锁：ptr_to_lock_record(62) + lock(2)
// 重量级锁：ptr_to_heavyweight_monitor(62) + lock(2)

public class LockComparison {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    // synchronized方式
    public synchronized void syncMethod() {
        count++;
    }

    // ReentrantLock方式
    public void lockMethod() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在finally中释放
        }
    }

    // ReentrantLock的高级功能
    public void advancedFeatures() throws InterruptedException {
        // 1. 尝试获取锁
        if (lock.tryLock()) {
            try {
                // 获取到锁的逻辑
            } finally {
                lock.unlock();
            }
        }

        // 2. 超时获取锁
        if (lock.tryLock(1, TimeUnit.SECONDS)) {
            try {
                // 1秒内获取到锁的逻辑
            } finally {
                lock.unlock();
            }
        }

        // 3. 可中断的锁获取
        try {
            lock.lockInterruptibly();
            // 可以被interrupt()中断
        } finally {
            lock.unlock();
        }
    }
}

public ThreadPoolExecutor(
    int corePoolSize,           // 1. 核心线程数
    int maximumPoolSize,        // 2. 最大线程数
    long keepAliveTime,         // 3. 空闲线程存活时间
    TimeUnit unit,              // 4. 时间单位
    BlockingQueue<Runnable> workQueue,  // 5. 工作队列
    ThreadFactory threadFactory,        // 6. 线程工厂
    RejectedExecutionHandler handler    // 7. 拒绝策略
) {
    // 构造器实现
}

public class ThreadPoolConfig {

    // CPU密集型任务
    public static ExecutorService createCpuIntensivePool() {
        int coreSize = Runtime.getRuntime().availableProcessors();
        return new ThreadPoolExecutor(
            coreSize,                    // 核心线程数 = CPU核数
            coreSize,                    // 最大线程数 = CPU核数
            0L, TimeUnit.MILLISECONDS,   // 不需要额外线程
            new LinkedBlockingQueue<>(), // 无界队列
            new ThreadFactory() {
                private final AtomicInteger threadNumber = new AtomicInteger(1);
                @Override
                public Thread newThread(Runnable r) {
                    Thread t = new Thread(r, "cpu-pool-" + threadNumber.getAndIncrement());
                    t.setDaemon(false);
                    return t;
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy() // 调用者执行策略
        );
    }

    // IO密集型任务
    public static ExecutorService createIoIntensivePool() {
        int coreSize = Runtime.getRuntime().availableProcessors() * 2;
        return new ThreadPoolExecutor(
            coreSize,                    // 核心线程数 = CPU核数 * 2
            coreSize * 2,                // 最大线程数 = CPU核数 * 4
            60L, TimeUnit.SECONDS,       // 空闲线程60秒后回收
            new ArrayBlockingQueue<>(100), // 有界队列，防止OOM
            r -> new Thread(r, "io-pool-" + System.currentTimeMillis()),
            new ThreadPoolExecutor.AbortPolicy() // 抛异常策略
        );
    }
}

// 1. ArrayBlockingQueue - 有界队列
BlockingQueue<Runnable> queue1 = new ArrayBlockingQueue<>(100);
// 特点：固定容量，防止OOM，但可能触发拒绝策略

// 2. LinkedBlockingQueue - 无界队列（默认Integer.MAX_VALUE）
BlockingQueue<Runnable> queue2 = new LinkedBlockingQueue<>();
// 特点：容量大，很少触发拒绝策略，但可能OOM

// 3. SynchronousQueue - 直接交换
BlockingQueue<Runnable> queue3 = new SynchronousQueue<>();
// 特点：不存储任务，直接交给线程执行

// 4. PriorityBlockingQueue - 优先级队列
BlockingQueue<Runnable> queue4 = new PriorityBlockingQueue<>();
// 特点：按优先级执行任务

// 1. AbortPolicy - 抛异常（默认）
new ThreadPoolExecutor.AbortPolicy()

// 2. CallerRunsPolicy - 调用者执行
new ThreadPoolExecutor.CallerRunsPolicy()

// 3. DiscardPolicy - 静默丢弃
new ThreadPoolExecutor.DiscardPolicy()

// 4. DiscardOldestPolicy - 丢弃最老的任务
new ThreadPoolExecutor.DiscardOldestPolicy()

// 5. 自定义策略
RejectedExecutionHandler customHandler = (r, executor) -> {
    // 记录日志
    logger.warn("Task rejected: {}", r.toString());
    // 可以选择重试、存储到数据库等
};