public enum State {
    NEW,              // 新建
    RUNNABLE,         // 可运行
    BLOCKED,          // 阻塞
    WAITING,          // 等待
    TIMED_WAITING,    // 定时等待
    TERMINATED        // 终止
}

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

// 使用
MyThread thread = new MyThread();
thread.start();  // 启动线程

// 实现Runnable接口
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
}

// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

// 使用Lambda表达式
Thread thread = new Thread(() -> {
    System.out.println("线程执行: " + Thread.currentThread().getName());
});
thread.start();

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

// 实现Callable接口
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "线程执行结果: " + Thread.currentThread().getName();
    }
}

// 使用
Callable<String> callable = new MyCallable();
FutureTask<String> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();

// 获取结果
String result = futureTask.get();  // 阻塞等待结果
System.out.println(result);

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(10);

// 提交任务
executor.submit(() -> {
    System.out.println("线程执行: " + Thread.currentThread().getName());
});

// 关闭线程池
executor.shutdown();

import java.util.concurrent.CompletableFuture;

// 异步执行
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "线程执行结果: " + Thread.currentThread().getName();
});

// 获取结果
future.thenAccept(result -> System.out.println(result));

public class Counter {
    private int count = 0;
    
    // 同步实例方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步静态方法
    public static synchronized void staticMethod() {
        // ...
    }
}

public class Counter {
    private int count = 0;
    private final Object lock = new Object();
    
    public void increment() {
        synchronized (lock) {
            count++;
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

// 非公平锁（默认）
ReentrantLock lock = new ReentrantLock();

// 公平锁
ReentrantLock fairLock = new ReentrantLock(true);

import java.util.concurrent.locks.Lock;

Lock lock = new ReentrantLock();

try {
    // 可中断的获取锁
    lock.lockInterruptibly();
    try {
        // 业务逻辑
    } finally {
        lock.unlock();
    }
} catch (InterruptedException e) {
    // 处理中断
    Thread.currentThread().interrupt();
}

public class VolatileExample {
    private volatile boolean flag = false;
    
    public void writer() {
        flag = true;  // 写操作
    }
    
    public void reader() {
        if (flag) {  // 读操作
            // ...
        }
    }
}

public class WaitNotifyExample {
    private final Object lock = new Object();
    private boolean condition = false;
    
    public void waitMethod() throws InterruptedException {
        synchronized (lock) {
            while (!condition) {
                lock.wait();  // 等待
            }
            // 条件满足，继续执行
        }
    }
    
    public void notifyMethod() {
        synchronized (lock) {
            condition = true;
            lock.notify();  // 唤醒一个等待线程
            // 或
            lock.notifyAll();  // 唤醒所有等待线程
        }
    }
}

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

public class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int CAPACITY = 10;
    private final Object lock = new Object();
    
    public void produce(int item) throws InterruptedException {
        synchronized (lock) {
            while (queue.size() == CAPACITY) {
                lock.wait();  // 队列满，等待
            }
            queue.offer(item);
            lock.notifyAll();  // 通知消费者
        }
    }
    
    public int consume() throws InterruptedException {
        synchronized (lock) {
            while (queue.isEmpty()) {
                lock.wait();  // 队列空，等待
            }
            int item = queue.poll();
            lock.notifyAll();  // 通知生产者
            return item;
        }
    }
}

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

public class ConditionExample {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private boolean flag = false;
    
    public void awaitMethod() throws InterruptedException {
        lock.lock();
        try {
            while (!flag) {
                condition.await();  // 等待
            }
        } finally {
            lock.unlock();
        }
    }
    
    public void signalMethod() {
        lock.lock();
        try {
            flag = true;
            condition.signal();  // 唤醒一个
            // 或
            condition.signalAll();  // 唤醒所有
        } finally {
            lock.unlock();
        }
    }
}

public class BoundedBuffer {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Object[] items = new Object[100];
    private int putptr, takeptr, count;
    
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();  // 队列满，等待
            }
            items[putptr] = x;
            if (++putptr == items.length) putptr = 0;
            ++count;
            notEmpty.signal();  // 通知消费者
        } finally {
            lock.unlock();
        }
    }
    
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();  // 队列空，等待
            }
            Object x = items[takeptr];
            if (++takeptr == items.length) takeptr = 0;
            --count;
            notFull.signal();  // 通知生产者
            return x;
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        int threadCount = 5;
        CountDownLatch latch = new CountDownLatch(threadCount);
        
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    // 执行任务
                    System.out.println("线程执行: " + Thread.currentThread().getName());
                } finally {
                    latch.countDown();  // 计数减1
                }
            }).start();
        }
        
        latch.await();  // 等待所有线程完成
        System.out.println("所有线程执行完毕");
    }
}

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int threadCount = 5;
        CyclicBarrier barrier = new CyclicBarrier(threadCount, () -> {
            System.out.println("所有线程到达屏障");
        });
        
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    System.out.println("线程到达屏障: " + Thread.currentThread().getName());
                    barrier.await();  // 等待其他线程
                    System.out.println("线程继续执行: " + Thread.currentThread().getName());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        int permits = 3;  // 允许3个线程同时访问
        Semaphore semaphore = new Semaphore(permits);
        
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();  // 获取许可
                    System.out.println("线程执行: " + Thread.currentThread().getName());
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();  // 释放许可
                }
            }).start();
        }
    }
}

import java.util.concurrent.Exchanger;

public class ExchangerExample {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();
        
        new Thread(() -> {
            try {
                String data = "Data from Thread 1";
                String received = exchanger.exchange(data);
                System.out.println("Thread 1 received: " + received);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        new Thread(() -> {
            try {
                String data = "Data from Thread 2";
                String received = exchanger.exchange(data);
                System.out.println("Thread 2 received: " + received);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.LinkedBlockingQueue;

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5,                          // corePoolSize: 核心线程数
    10,                         // maximumPoolSize: 最大线程数
    60L,                        // keepAliveTime: 空闲线程存活时间
    TimeUnit.SECONDS,           // unit: 时间单位
    new LinkedBlockingQueue<>(), // workQueue: 工作队列
    new ThreadFactory() {       // threadFactory: 线程工厂
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("MyThread-" + t.getId());
            return t;
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy()  // handler: 拒绝策略
);

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

// 2. CallerRunsPolicy：调用者运行
new ThreadPoolExecutor.CallerRunsPolicy()

// 3. DiscardPolicy：直接丢弃
new ThreadPoolExecutor.DiscardPolicy()

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

public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 自定义处理逻辑
        System.out.println("任务被拒绝: " + r);
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

// 1. 固定大小线程池
ExecutorService fixedPool = Executors.newFixedThreadPool(10);

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

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

// 4. 定时任务线程池
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinExample {
    static class SumTask extends RecursiveTask<Long> {
        private final int[] array;
        private final int start;
        private final int end;
        private static final int THRESHOLD = 100;
        
        public SumTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }
        
        @Override
        protected Long compute() {
            if (end - start <= THRESHOLD) {
                // 直接计算
                long sum = 0;
                for (int i = start; i < end; i++) {
                    sum += array[i];
                }
                return sum;
            } else {
                // 分而治之
                int mid = (start + end) / 2;
                SumTask left = new SumTask(array, start, mid);
                SumTask right = new SumTask(array, mid, end);
                left.fork();  // 异步执行
                long rightResult = right.compute();  // 同步执行
                long leftResult = left.join();  // 等待结果
                return leftResult + rightResult;
            }
        }
    }
    
    public static void main(String[] args) {
        int[] array = new int[1000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }
        
        ForkJoinPool pool = new ForkJoinPool();
        SumTask task = new SumTask(array, 0, array.length);
        long result = pool.invoke(task);
        System.out.println("结果: " + result);
    }
}

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

// 线程安全的操作
map.put("key1", "value1");
String value = map.get("key1");
map.remove("key1");

// 原子操作
map.putIfAbsent("key2", "value2");
map.replace("key2", "value2", "newValue");

// 关键字段
transient volatile Node<K,V>[] table;  // 哈希表
private transient volatile int sizeCtl;  // 控制标识符

// put操作（简化版）
final V putVal(K key, V value, boolean onlyIfAbsent) {
    // 1. 计算hash值
    int hash = spread(key.hashCode());
    
    // 2. 循环插入
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();  // 初始化
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 3. CAS插入
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;
        } else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);  // 协助扩容
        else {
            // 4. synchronized锁住链表头节点
            synchronized (f) {
                // 插入或更新
            }
        }
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

// 创建CompletableFuture
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "Hello";
});

// 链式调用
CompletableFuture<String> result = CompletableFuture
    .supplyAsync(() -> "Hello")
    .thenApply(s -> s + " World")
    .thenApply(String::toUpperCase);

// 组合多个Future
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
CompletableFuture<String> combined = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);

// 异常处理
CompletableFuture<String> future = CompletableFuture
    .supplyAsync(() -> {
        if (true) throw new RuntimeException("Error");
        return "Success";
    })
    .exceptionally(ex -> "Error: " + ex.getMessage());

public class Thread implements Runnable {
    // 线程名称
    private volatile String name;
    
    // 线程优先级
    private int priority;
    
    // 线程状态
    private volatile int threadStatus = 0;
    
    // 线程组
    private ThreadGroup group;
    
    // 目标Runnable
    private Runnable target;
    
    // 线程本地变量
    ThreadLocal.ThreadLocalMap threadLocals;
    
    // 启动线程
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        
        group.add(this);
        boolean started = false;
        try {
            start0();  // 本地方法，创建操作系统线程
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    
    private native void start0();  // JNI调用
}

// 无锁状态
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 |

// 偏向锁
| thread:54 | epoch:2 | unused:1 | age:4 | biased_lock:1 | lock:2 |

// 轻量级锁
| ptr_to_lock_record:62 | lock:2 |

// 重量级锁
| ptr_to_monitor:62 | lock:2 |

// 第一次访问，CAS设置线程ID
if (mark == 无锁状态) {
    CAS(mark, threadId);
    return 偏向锁;
}

// 有竞争，CAS自旋
if (mark == 偏向锁 && threadId != currentThread) {
    // 撤销偏向锁
    // CAS获取轻量级锁
    return 轻量级锁;
}

// 竞争激烈，升级为重量级锁
if (自旋失败) {
    // 创建Monitor对象
    // 线程进入等待队列
    return 重量级锁;
}

public abstract class AbstractQueuedSynchronizer {
    // 尝试获取锁（子类实现）
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
    
    // 获取锁（模板方法）
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
    
    // 释放锁（模板方法）
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
}

// 线程数 = CPU核心数 + 1
int corePoolSize = Runtime.getRuntime().availableProcessors() + 1;
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,
    corePoolSize,
    0L,
    TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<>(1000),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

// 线程数 = CPU核心数 × 2
int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,
    corePoolSize * 2,
    60L,
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

public class ThreadPoolMonitor {
    private final ThreadPoolExecutor executor;
    
    public void monitor() {
        System.out.println("核心线程数: " + executor.getCorePoolSize());
        System.out.println("最大线程数: " + executor.getMaximumPoolSize());
        System.out.println("当前线程数: " + executor.getPoolSize());
        System.out.println("活跃线程数: " + executor.getActiveCount());
        System.out.println("已完成任务数: " + executor.getCompletedTaskCount());
        System.out.println("总任务数: " + executor.getTaskCount());
        System.out.println("队列大小: " + executor.getQueue().size());
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AsyncTaskProcessor {
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public CompletableFuture<String> processAsync(String data) {
        return CompletableFuture.supplyAsync(() -> {
            // 异步处理
            return processData(data);
        }, executor);
    }
    
    private String processData(String data) {
        // 业务逻辑
        return "Processed: " + data;
    }
    
    public void shutdown() {
        executor.shutdown();
    }
}

import java.util.concurrent.atomic.AtomicLong;

public class ConcurrentCounter {
    private final AtomicLong count = new AtomicLong(0);
    
    public void increment() {
        count.incrementAndGet();
    }
    
    public long get() {
        return count.get();
    }
}