线程安全与并发问题

public class Counter {
    private int count = 0;
    
    public void increment() {
        count++;  // 非原子操作
    }
}

线程1: 读取 count=0
线程2: 读取 count=0
线程1: 计算 0+1=1
线程2: 计算 0+1=1
线程1: 写入 count=1
线程2: 写入 count=1  // 覆盖了线程1的结果

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();  // 原子操作
    }
    
    public int getCount() {
        return count.get();
    }
}

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

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

// 高并发下性能对比
public class CounterComparison {
    private AtomicInteger atomicInt = new AtomicInteger();
    private LongAdder longAdder = new LongAdder();
    
    // AtomicInteger: 高并发下有竞争热点
    public void incrementAtomic() {
        atomicInt.incrementAndGet();  // CAS 循环重试
    }
    
    // LongAdder: 分散热点,性能更好
    public void incrementLongAdder() {
        longAdder.increment();  // 多个 Cell 分散更新
    }
}

public class VisibilityProblem {
    private boolean running = true;
    
    public void stop() {
        running = false;  // 主线程修改
    }
    
    public void doWork() {
        while (running) {  // 工作线程可能看不到修改
            // do something
        }
    }
}

public class VisibilitySolved {
    private volatile boolean running = true;
    
    public void stop() {
        running = false;
    }
    
    public void doWork() {
        while (running) {
            // volatile 保证每次都从主内存读取最新值
        }
    }
}

public class VisibilitySolved {
    private boolean running = true;
    
    public synchronized void stop() {
        running = false;
    }
    
    public synchronized boolean isRunning() {
        return running;
    }
}

public class FinalVisibility {
    private final int value;
    
    public FinalVisibility(int value) {
        this.value = value;  // final 字段在构造函数中初始化后,其他线程立即可见
    }
    
    public int getValue() {
        return value;  // 不需要同步
    }
}

public class OrderProblem {
    private int a = 0;
    private boolean flag = false;
    
    // 线程1
    public void writer() {
        a = 1;           // 1
        flag = true;     // 2
    }
    
    // 线程2
    public void reader() {
        if (flag) {      // 3
            int i = a;   // 4
        }
    }
}

public class OrderSolved {
    private int a = 0;
    private volatile boolean flag = false;
    
    public void writer() {
        a = 1;
        flag = true;  // volatile 写,前面的普通写不会被重排序到后面
    }
    
    public void reader() {
        if (flag) {  // volatile 读,后面的普通读不会被重排序到前面
            int i = a;  // 此时 a 一定已经是 1
        }
    }
}

public class OrderSolved {
    private int a = 0;
    private boolean flag = false;
    
    public synchronized void writer() {
        a = 1;
        flag = true;
    }
    
    public synchronized void reader() {
        if (flag) {
            int i = a;
        }
    }
}

线程安全
    ├── 原子性: 操作不可分割
    ├── 可见性: 修改立即可见
    └── 有序性: 执行顺序可预测
 
保障方式:
    ├── synchronized: 保证全部三个特性
    ├── volatile: 保证可见性和有序性,不保证原子性
    ├── final: 保证初始化完成后的可见性
    ├── 原子类: 保证原子性
    └── Lock: 保证全部三个特性

public final class ImmutableObject {
    private final int value;
    private final String name;
    private final List<String> list;
    
    public ImmutableObject(int value, String name, List<String> list) {
        this.value = value;
        this.name = name;
        this.list = Collections.unmodifiableList(new ArrayList<>(list));  // 防御性拷贝
    }
    
    public int getValue() {
        return value;
    }
    
    public String getName() {
        return name;
    }
    
    public List<String> getList() {
        return list;  // 已经是不可变的
    }
    
    // 不提供 setter 方法
}

// String 是典型的不可变对象
String s1 = "hello";
String s2 = s1.toUpperCase();  // 返回新对象,原对象不变
 
// BigInteger、BigDecimal 也是不可变对象
BigInteger b1 = new BigInteger("123");
BigInteger b2 = b1.add(new BigInteger("456"));  // 返回新对象
 
// 使用不可变对象作为 Map 的 key
Map<String, Integer> map = new HashMap<>();
map.put("key", 1);  // String 是不可变的,线程安全

public class SynchronizedExample {
    private int count = 0;
    
    public synchronized void increment() {
        count++;  // 锁 this
    }
    
    public synchronized int getCount() {
        return count;  // 锁 this
    }
}

public class SynchronizedExample {
    private static int count = 0;
    
    public static synchronized void increment() {
        count++;  // 锁 SynchronizedExample.class
    }
    
    public static synchronized int getCount() {
        return count;  // 锁 SynchronizedExample.class
    }
}

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

无锁 → 偏向锁 → 轻量级锁 → 重量级锁

// 1. 对象创建,默认无锁或偏向锁（取决于 JVM 配置）
Object obj = new Object();
 
// 2. 第一个线程访问,获取偏向锁
synchronized (obj) {
    // 偏向锁: Mark Word 记录线程 ID
}
 
// 3. 另一个线程尝试获取,升级为轻量级锁
synchronized (obj) {
    // 轻量级锁: CAS 操作 Mark Word
}
 
// 4. 竞争激烈,升级为重量级锁
synchronized (obj) {
    // 重量级锁: 监视器锁,线程阻塞
}

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();  // 获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 必须在 finally 中释放锁
        }
    }
    
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

public void tryLockWithTimeout() throws InterruptedException {
    // 尝试获取锁,最多等待 5 秒
    if (lock.tryLock(5, TimeUnit.SECONDS)) {
        try {
            // 获取锁成功
        } finally {
            lock.unlock();
        }
    } else {
        // 获取锁失败
    }
}
 
public void lockInterruptibly() throws InterruptedException {
    // 可响应中断的锁获取
    lock.lockInterruptibly();
    try {
        // 执行业务逻辑
    } finally {
        lock.unlock();
    }
}

// 非公平锁（默认）: 效率高,但可能导致线程饥饿
ReentrantLock unfairLock = new ReentrantLock();
 
// 公平锁: 按照请求锁的顺序获取,但效率低
ReentrantLock fairLock = new ReentrantLock(true);

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 putIndex, takeIndex, count;
    
    public void put(Object item) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                notFull.await();  // 等待不满条件
            }
            items[putIndex] = item;
            if (++putIndex == items.length) putIndex = 0;
            count++;
            notEmpty.signal();  // 通知不空条件
        } finally {
            lock.unlock();
        }
    }
    
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();  // 等待不空条件
            }
            Object item = items[takeIndex];
            if (++takeIndex == items.length) takeIndex = 0;
            count--;
            notFull.signal();  // 通知不满条件
            return item;
        } finally {
            lock.unlock();
        }
    }
}

// 同步容器: 所有方法都用 synchronized 修饰
Vector<String> vector = new Vector<>();
vector.add("element");  // synchronized
 
Hashtable<String, String> hashtable = new Hashtable<>();
hashtable.put("key", "value");  // synchronized

// 将普通容器包装成同步容器
List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Map<String, String> synchronizedMap = Collections.synchronizedMap(new HashMap<>());
Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());

// 复合操作不是原子的
List<String> list = Collections.synchronizedList(new ArrayList<>());
 
// 线程不安全的复合操作
if (!list.contains("element")) {
    list.add("element");  // 在 contains 和 add 之间可能被其他线程修改
}
 
// 需要额外的同步
synchronized (list) {
    if (!list.contains("element")) {
        list.add("element");
    }
}
 
// 迭代时需要同步
synchronized (list) {
    for (String s : list) {
        // 如果不同步,其他线程修改可能导致 ConcurrentModificationException
    }
}

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
 
// 原子复合操作
map.putIfAbsent("key", 1);  // 如果 key 不存在才插入
map.computeIfAbsent("key", k -> calculateValue(k));  // 如果 key 不存在才计算并插入
map.computeIfPresent("key", (k, v) -> v + 1);  // 如果 key 存在才更新
map.replace("key", 1, 2);  // 如果值匹配才替换
 
// 批量操作（Java 8+）
map.forEach((k, v) -> System.out.println(k + "=" + v));
map.replaceAll((k, v) -> v * 2);
map.merge("key", 1, (oldVal, newVal) -> oldVal + newVal);

// Java 8 ConcurrentHashMap 的 put 操作大致流程
public V put(K key, V value) {
    // 1. 计算 hash
    int hash = spread(key.hashCode());
    
    // 2. 遍历 table
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        
        // 3. 如果桶为空,CAS 插入新节点
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;  // CAS 成功,插入完成
        }
        // 4. 如果正在扩容,帮助扩容
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        // 5. 否则锁住头节点,插入或更新
        else {
            synchronized (f) {
                // 遍历链表或红黑树,插入或更新节点
            }
        }
    }
    return null;
}

// 适用于读多写少的场景
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
 
// 读操作: 不加锁,直接访问
String element = list.get(0);
 
// 写操作: 复制整个数组
list.add("element");  // 复制原数组,添加元素,替换原数组
list.remove(0);       // 复制原数组,删除元素,替换原数组
 
// 迭代: 不需要同步,不会抛出 ConcurrentModificationException
for (String s : list) {
    // 迭代的是原数组的快照
}

// ArrayBlockingQueue: 有界阻塞队列
BlockingQueue<String> arrayQueue = new ArrayBlockingQueue<>(100);
arrayQueue.put("element");  // 队列满时阻塞
String element = arrayQueue.take();  // 队列空时阻塞
 
// LinkedBlockingQueue: 可选有界/无界阻塞队列
BlockingQueue<String> linkedQueue = new LinkedBlockingQueue<>(100);
BlockingQueue<String> unboundedQueue = new LinkedBlockingQueue<>();  // 无界
 
// SynchronousQueue: 无缓冲,直接传递
BlockingQueue<String> syncQueue = new SynchronousQueue<>();
new Thread(() -> {
    try {
        syncQueue.put("element");  // 等待消费者
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();
new Thread(() -> {
    try {
        String e = syncQueue.take();  // 等待生产者
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();
 
// PriorityBlockingQueue: 优先级队列
BlockingQueue<Integer> priorityQueue = new PriorityBlockingQueue<>();
priorityQueue.put(3);
priorityQueue.put(1);
priorityQueue.put(2);
// take 时按优先级（自然排序）出队: 1, 2, 3
 
// DelayQueue: 延迟队列
class DelayedElement implements Delayed {
    private final long expireTime;
    
    public DelayedElement(long delay) {
        this.expireTime = System.nanoTime() + delay;
    }
    
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expireTime - System.nanoTime(), TimeUnit.NANOSECONDS);
    }
    
    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.expireTime, ((DelayedElement) o).expireTime);
    }
}
 
DelayQueue<DelayedElement> delayQueue = new DelayQueue<>();
delayQueue.put(new DelayedElement(TimeUnit.SECONDS.toNanos(5)));  // 5 秒后可用

// 高性能无界非阻塞队列
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
 
// 无阻塞操作
queue.offer("element");  // 入队
String element = queue.poll();  // 出队,队列为空返回 null
String peek = queue.peek();  // 查看队首,不出队
 
// 适用于高并发场景,性能优于 BlockingQueue

// 每个线程独立的变量副本
public class ThreadLocalExample {
    private static final ThreadLocal<Integer> threadLocalValue = ThreadLocal.withInitial(() -> 0);
    
    public void setValue(int value) {
        threadLocalValue.set(value);
    }
    
    public int getValue() {
        return threadLocalValue.get();
    }
    
    public void remove() {
        threadLocalValue.remove();  // 防止内存泄漏
    }
}

public class ConnectionManager {
    private static final ThreadLocal<Connection> connectionHolder = new ThreadLocal<>();
    
    public static Connection getConnection() {
        Connection conn = connectionHolder.get();
        if (conn == null) {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb");
            connectionHolder.set(conn);
        }
        return conn;
    }
    
    public static void closeConnection() {
        Connection conn = connectionHolder.get();
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                // 处理异常
            } finally {
                connectionHolder.remove();  // 必须清理
            }
        }
    }
}

public class UserContext {
    private static final ThreadLocal<User> userHolder = new ThreadLocal<>();
    
    public static void setUser(User user) {
        userHolder.set(user);
    }
    
    public static User getUser() {
        return userHolder.get();
    }
    
    public static void clear() {
        userHolder.remove();
    }
}
 
// 在拦截器中设置用户上下文
public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        User user = getUserFromToken(request.getHeader("Authorization"));
        UserContext.setUser(user);
        return true;
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        UserContext.clear();  // 必须清理
    }
}

// SimpleDateFormat 不是线程安全的
public class DateFormatter {
    private static final ThreadLocal<SimpleDateFormat> dateFormatHolder = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    
    public static String format(Date date) {
        return dateFormatHolder.get().format(date);
    }
    
    public static Date parse(String dateStr) throws ParseException {
        return dateFormatHolder.get().parse(dateStr);
    }
}

// ThreadLocal 的内部结构
Thread
    └── threadLocals (ThreadLocalMap)
            └── Entry (WeakReference<ThreadLocal<?>> key, Object value)
 
// Entry 的 key 是弱引用,会被 GC 回收
// 但 value 是强引用,如果线程长期存活,value 不会被回收
 
// 必须手动清理
try {
    threadLocal.set(value);
    // 使用 value
} finally {
    threadLocal.remove();  // 防止内存泄漏
}

// 1. 使用 static final 修饰
private static final ThreadLocal<User> userHolder = new ThreadLocal<>();
 
// 2. 在 finally 块中清理
try {
    userHolder.set(user);
    // 业务逻辑
} finally {
    userHolder.remove();
}
 
// 3. 在线程池中使用时要特别注意
ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> {
    try {
        userHolder.set(user);
        // 业务逻辑
    } finally {
        userHolder.remove();  // 线程池中线程会复用,必须清理
    }
});

// 错误的双重检查锁定
public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {                    // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {            // 第二次检查
                    instance = new Singleton();    // 非原子操作
                }
            }
        }
        return instance;
    }
}

public class Singleton {
    private static volatile Singleton instance;  // volatile 禁止指令重排序
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class DeadlockDemo {
    private static final Object fork1 = new Object();
    private static final Object fork2 = new Object();
    private static final Object fork3 = new Object();
    
    public static void main(String[] args) {
        // 哲学家1: 先拿 fork1,再拿 fork2
        new Thread(() -> {
            synchronized (fork1) {
                System.out.println("哲学家1 拿起 fork1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (fork2) {
                    System.out.println("哲学家1 拿起 fork2,开始进餐");
                }
            }
        }).start();
        
        // 哲学家2: 先拿 fork2,再拿 fork3
        new Thread(() -> {
            synchronized (fork2) {
                System.out.println("哲学家2 拿起 fork2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (fork3) {
                    System.out.println("哲学家2 拿起 fork3,开始进餐");
                }
            }
        }).start();
        
        // 哲学家3: 先拿 fork3,再拿 fork1
        new Thread(() -> {
            synchronized (fork3) {
                System.out.println("哲学家3 拿起 fork3");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (fork1) {
                    System.out.println("哲学家3 拿起 fork1,开始进餐");
                }
            }
        }).start();
    }
}

// 修改哲学家进餐问题：所有哲学家按 fork 编号从小到大获取
public class DeadlockFree {
    public static void main(String[] args) {
        // 所有哲学家按 fork 编号从小到大获取
        new Thread(() -> {
            synchronized (fork1) {
                System.out.println("哲学家1 拿起 fork1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (fork2) {
                    System.out.println("哲学家1 拿起 fork2,开始进餐");
                }
            }
        }).start();
        
        new Thread(() -> {
            synchronized (fork2) {  // 先拿 fork2
                System.out.println("哲学家2 拿起 fork2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (fork3) {  // 再拿 fork3
                    System.out.println("哲学家2 拿起 fork3,开始进餐");
                }
            }
        }).start();
        
        new Thread(() -> {
            synchronized (fork1) {  // 先拿 fork1（编号最小的）
                System.out.println("哲学家3 拿起 fork1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (fork3) {  // 再拿 fork3
                    System.out.println("哲学家3 拿起 fork3,开始进餐");
                }
            }
        }).start();
    }
}

public class HoldAndWaitFree {
    private static final Object lock = new Object();
    
    public void transfer(Account from, Account to, int amount) {
        synchronized (lock) {  // 先获取全局锁
            synchronized (from) {
                synchronized (to) {
                    from.debit(amount);
                    to.credit(amount);
                }
            }
        }
    }
}

public class TimeoutLock {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();
    
    public void transfer() {
        boolean lock1Acquired = false;
        boolean lock2Acquired = false;
        
        try {
            lock1Acquired = lock1.tryLock(100, TimeUnit.MILLISECONDS);
            if (lock1Acquired) {
                lock2Acquired = lock2.tryLock(100, TimeUnit.MILLISECONDS);
                if (lock2Acquired) {
                    // 执行业务逻辑
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (lock2Acquired) {
                lock2.unlock();
            }
            if (lock1Acquired) {
                lock1.unlock();
            }
        }
    }
}

# 1. 使用 jstack 检测死锁
jstack <pid>
 
# 2. 使用 jconsole 检测死锁
jconsole
 
# 3. 使用 VisualVM 检测死锁
jvisualvm

public class LivelockDemo {
    static class Spoon {
        private Diner owner;
        
        public Spoon(Diner owner) {
            this.owner = owner;
        }
        
        public Diner getOwner() {
            return owner;
        }
        
        public synchronized void setOwner(Diner owner) {
            this.owner = owner;
        }
        
        public synchronized void use() {
            System.out.println(owner.name + " 使用勺子");
        }
    }
    
    static class Diner {
        private String name;
        private boolean isHungry;
        
        public Diner(String name) {
            this.name = name;
            this.isHungry = true;
        }
        
        public void eatWith(Spoon spoon, Diner spouse) {
            while (isHungry) {
                // 如果勺子不在自己手里,等待
                if (spoon.getOwner() != this) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    continue;
                }
                
                // 如果配偶也饿,就把勺子给配偶
                if (spouse.isHungry) {
                    System.out.println(name + ": " + spouse.name + " 也饿了,把勺子给他");
                    spoon.setOwner(spouse);
                    continue;
                }
                
                // 使用勺子吃饭
                spoon.use();
                isHungry = false;
                System.out.println(name + " 吃完了");
                spoon.setOwner(spouse);
            }
        }
    }
    
    public static void main(String[] args) {
        Diner husband = new Diner("丈夫");
        Diner wife = new Diner("妻子");
        Spoon spoon = new Spoon(husband);
        
        new Thread(() -> husband.eatWith(spoon, wife)).start();
        new Thread(() -> wife.eatWith(spoon, husband)).start();
    }
}

public class LivelockFree {
    static class Diner {
        private String name;
        private boolean isHungry;
        private int retryCount = 0;
        private static final int MAX_RETRY = 3;
        
        public void eatWith(Spoon spoon, Diner spouse) {
            while (isHungry && retryCount < MAX_RETRY) {
                if (spoon.getOwner() != this) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    continue;
                }
                
                // 如果配偶也饿,有概率把勺子给配偶
                if (spouse.isHungry) {
                    retryCount++;
                    // 引入随机性,避免同时让步
                    if (Math.random() > 0.5) {
                        spoon.setOwner(spouse);
                    }
                    continue;
                }
                
                spoon.use();
                isHungry = false;
                spoon.setOwner(spouse);
            }
        }
    }
}

// 非公平锁可能导致饥饿
ReentrantLock unfairLock = new ReentrantLock(false);  // 默认非公平
 
// 使用公平锁避免饥饿
ReentrantLock fairLock = new ReentrantLock(true);

public class PriorityStarvation {
    public static void main(String[] args) {
        // 高优先级线程
        Thread highPriority = new Thread(() -> {
            while (true) {
                // CPU 密集型任务
            }
        });
        highPriority.setPriority(Thread.MAX_PRIORITY);  // 优先级 10
        
        // 低优先级线程
        Thread lowPriority = new Thread(() -> {
            while (true) {
                // 可能长期得不到执行
            }
        });
        lowPriority.setPriority(Thread.MIN_PRIORITY);  // 优先级 1
        
        highPriority.start();
        lowPriority.start();
    }
}

public class LongLockTime {
    private final Object lock = new Object();
    
    public void longTask() {
        synchronized (lock) {
            // 长时间持有锁
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    
    public void shortTask() {
        synchronized (lock) {  // 长时间等待
            // 短时间任务
        }
    }
}

public class ThreadPoolProblem {
    public static void main(String[] args) {
        // 线程池配置不合理
        ExecutorService executor = new ThreadPoolExecutor(
            10,  // 核心线程数
            10,  // 最大线程数
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(),  // 无界队列,可能导致 OOM
            new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
        );
        
        // 任务提交速度 > 处理速度
        for (int i = 0; i < 100000; i++) {
            executor.submit(() -> {
                try {
                    Thread.sleep(1000);  // 慢任务
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
    }
}

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10,
    20,
    60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),  // 有界队列
    new ThreadPoolExecutor.CallerRunsPolicy()  // 调用者执行
);

public void monitorThreadPool(ThreadPoolExecutor executor) {
    ScheduledExecutorService monitor = Executors.newScheduledThreadPool(1);
    monitor.scheduleAtFixedRate(() -> {
        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.getQueue().size());
    }, 0, 1, TimeUnit.SECONDS);
}

public void adjustThreadPool(ThreadPoolExecutor executor, int corePoolSize, int maxPoolSize) {
    executor.setCorePoolSize(corePoolSize);
    executor.setMaximumPoolSize(maxPoolSize);
}

# 查看 Java 进程 PID
jps -l
 
# 输出线程堆栈
jstack <pid>
 
# 输出线程堆栈到文件
jstack <pid> > thread_dump.txt
 
# 检测死锁
jstack -l <pid>

// 线程堆栈示例
"http-nio-8080-exec-1" #25 daemon prio=5 os_prio=0 tid=0x00007f8a9c001000 nid=0x7a03 waiting on condition [0x00007f8a8c1f8000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x00000000e1a2a8c0> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
        at com.example.UserService.transfer(UserService.java:25)
        at com.example.TransferController.transfer(TransferController.java:15)
        ...

# 找到 CPU 使用率高的进程
top -H -p <pid>
 
# 找到 CPU 使用率高的线程
printf "%x\n" <tid>  # 转换为十六进制
 
# 在 jstack 输出中搜索
jstack <pid> | grep -A 20 <hex_tid>

jstack -l <pid> | grep -A 10 "Found one Java-level deadlock"

Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x00007f8a9c0034c8 (object 0x00000000e1a2a8c0, a java.lang.Object),
  which is held by "Thread-2"
"Thread-2":
  waiting to lock monitor 0x00007f8a9c0032c8 (object 0x00000000e1a2a8d0, a java.lang.Object),
  which is held by "Thread-1"
 
Java stack information for the threads listed above:
===================================================
"Thread-1":
        at com.example.DeadlockDemo.run(DeadlockDemo.java:25)
        - waiting to lock <0x00000000e1a2a8c0> (a java.lang.Object)
        - locked <0x00000000e1a2a8d0> (a java.lang.Object)
"Thread-2":
        at com.example.DeadlockDemo.run(DeadlockDemo.java:35)
        - waiting to lock <0x00000000e1a2a8d0> (a java.lang.Object)
        - locked <0x00000000e1a2a8c0> (a java.lang.Object)
 
Found 1 deadlock.

jconsole

# 1. 启动应用,开启 JMX 远程监控
java -Dcom.sun.management.jmxremote \
     -Dcom.sun.management.jmxremote.port=9010 \
     -Dcom.sun.management.jmxremote.authenticate=false \
     -Dcom.sun.management.jmxremote.ssl=false \
     -jar app.jar
 
# 2. 使用 jconsole 连接
#    本地进程: 选择本地 Java 进程
#    远程进程: 输入 hostname:port

线程数: 25
峰值: 30
总启动线程数: 45
 
线程列表:
- main (RUNNABLE)
- http-nio-8080-exec-1 (WAITING)
- http-nio-8080-exec-2 (BLOCKED)
- ...
 
点击"检测死锁"按钮,自动检测是否存在死锁

jvisualvm

// 1. 应用启动时开启 JMX
java -Dcom.sun.management.jmxremote=true \
     -Dcom.sun.management.jmxremote.port=9010 \
     -Dcom.sun.management.jmxremote.authenticate=false \
     -Dcom.sun.management.jmxremote.ssl=false \
     -jar app.jar
 
// 2. VisualVM 连接后,点击"堆 Dump"
// 3. 在堆 dump 页面,点击"类",按实例数排序
// 4. 找到实例数异常多的类
// 5. 右键点击类,选择"在堆中显示"
// 6. 查看对象引用链,找到 GC Root

// 1. VisualVM 连接应用
// 2. 点击"Sampler"标签
// 3. 点击"CPU"按钮开始采样
// 4. 执行业务操作
// 5. 点击"Stop"停止采样
// 6. 查看方法执行时间排序
// 7. 找到耗时最长的方法
 
// 示例输出:
Method                          Time (ms)  Invocations
com.example.UserService.getUser    5000        100
com.example.UserService.queryDB    4500        100
com.example.CacheService.get       500         1000

# 下载并启动
curl -O https://arthas.aliyun.com/arthas-boot.jar
java -jar arthas-boot.jar
 
# 选择要诊断的 Java 进程
# Arthas 会自动列出所有 Java 进程

# 查看所有线程
thread
 
# 查看指定线程
thread <thread_id>
 
# 查看 CPU 使用率最高的 3 个线程
thread -n 3
 
# 查看处于 BLOCKED 状态的线程
thread -state BLOCKED
 
# 检测死锁
thread -b

thread -n 3
"C1 CompilerThread0" [Internal] cpuUsage=45.23% deltaTime=0ms time=12345ms
"C2 CompilerThread0" [Internal] cpuUsage=32.15% deltaTime=0ms time=11234ms
"http-nio-8080-exec-1" cpuUsage=12.34% deltaTime=0ms time=5678ms

# 监控方法执行时间
trace com.example.UserService getUser
 
# 监控方法调用路径
trace com.example.UserService getUser '#cost > 100'  # 只显示耗时 > 100ms 的调用
 
# 监控方法调用次数和成功率
monitor -c 5 com.example.UserService getUser  # 每 5 秒输出一次统计

`---[12.345ms] com.example.UserService:getUser()
    +---[0.123ms] com.example.CacheService:get()
    `---[12.222ms] com.example.UserDao:queryById()
        `---[12.111ms] java.sql.PreparedStatement:executeQuery()

# 查看方法入参和返回值
watch com.example.UserService getUser '{params, returnObj}' -x 2
 
# 查看方法入参、返回值和异常
watch com.example.UserService getUser '{params, returnObj, throwExp}' -x 2
 
# 条件过滤
watch com.example.UserService getUser '{params, returnObj}' 'params[0] > 100' -x 2

method=com.example.UserService.getUser location=AtExit
ts=2024-01-01 10:00:00; result=@ArrayList[
    @Object[][
        @Integer[1],
    ],
    @User[
        id=@Integer[1],
        name=@String[张三],
        age=@Integer[25],
    ],
]

# 查看日志级别
logger
 
# 修改日志级别
logger --name com.example --level debug

# 查看类信息
sc -d com.example.UserService
 
# 查看类的方法
sm com.example.UserService
 
# 查看 JVM 已加载的类
sc -d *UserService*

# 反编译类
jad com.example.UserService
 
# 反编译指定方法
jad com.example.UserService getUser

# 查看 JVM 基本信息
jvm
 
# 查看 GC 信息
memory
 
# 查看 ClassLoader
classloader

# 1. 使用 trace 监控接口方法
trace com.example.OrderController createOrder
 
# 2. 发现某方法耗时较长
`---[1234.567ms] com.example.OrderController:createOrder()
    +---[1.234ms] com.example.ValidationService:validate()
    +---[1233.333ms] com.example.InventoryService:checkStock()
    |   `---[1233.111ms] com.example.InventoryDao:queryStock()
    |       `---[1232.999ms] java.sql.PreparedStatement:executeQuery()
    `---[0.001ms] com.example.OrderService:createOrder()
 
# 3. 进一步追踪数据库查询
trace com.example.InventoryDao queryStock
 
# 4. 发现 SQL 执行慢
`---[1232.999ms] com.example.InventoryDao:queryStock()
    `---[1232.888ms] java.sql.PreparedStatement:executeQuery()
 
# 5. 查看数据库连接池状态
vmtool --action getInstances --className com.zaxxer.hikari.HikariDataSource --express 'instances.{? #this.poolName == "mypool"}.{#this.getHikariPoolMXBean().{#this.getActiveConnections(), #this.getIdleConnections(), #this.getThreadsAwaitingConnection()}}'